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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
53ce80b6f1cafc1afd3d942a143fa7d85e4e6b38eccdc6331a12f242cdc1b728
| 12,811 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xa9f06cf165fe40f6e52f5765389f2d79dfc567ff.sol
| 3,404 | 12,735 |
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;
}
}
contract FueldToken{
using SafeMath for uint256;
address public multisig;
address public multisigPreICO;
address public owner;
address public extOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event MultisigsChanged(address _multisig, address _multisigPreICO);
function changeMultisigs(address _multisig, address _multisigPreICO) onlyOwner public {
require(_multisig != address(0));
require(_multisigPreICO != address(0));
multisig = _multisig;
multisigPreICO = _multisigPreICO;
MultisigsChanged(multisig, multisigPreICO);
}
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
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];
}
mapping (address => mapping (address => uint256)) allowed;
event Approval(address indexed owner_, address indexed spender, uint256 value);
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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
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 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;
}
uint256 public totalSupply = 200000000;
mapping (address => uint256) public privatePreICOdepositors;
mapping (address => uint256) public preICOdepositors;
mapping (address => uint256) public ICOdepositors;
mapping (address => uint256) public ICObalances;
uint256 constant public softCap = 6700 ether;
uint256 constant public hardCap = 67000 ether;
uint256 constant public price = 456000000000000 wei;
uint256 constant public maxPreICOSupply = 13500000;
uint256 constant public maxPreICOandICOSupply = 150000000;
uint256 constant public privatePreICOFreeBonusPercent = 35;
uint256 constant public preICOFreeBonusPercent = 30;
uint256 constant public privatePreICOBonusPercent = 0;
uint256 constant public preICOBonusPercent = 0;
uint256 constant public ICOBonusPercent1week = 15;
uint256 constant public ICOBonusPercent2week = 10;
uint256 constant public ICOBonusPercent3week = 5;
uint256 constant public restrictedPercent = 25;
uint256 public startTimePrivatePreICO = 0;
uint256 public startTimePreICO = 0;
uint256 public startTimeICO = 0;
uint256 public soldTokenCount = 0;
uint256 public cap = 0;
uint256 public capPreICO = 0;
uint256 public capPreICOTrasferred = 0;
uint256 public capFiat = 0;
uint256 public capFiatAndETH = 0;
bool public capReached = false;
event SaleStatus(string indexed status, uint256 indexed _date);
function startPrivatePreICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimePreICO = now;
startTimePrivatePreICO = startTimePreICO;
SaleStatus('Private Pre ICO started', startTimePreICO);
}
function startPreICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimePreICO = now;
SaleStatus('Public Pre ICO started', startTimePreICO);
}
function startICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimeICO = now;
SaleStatus('start ICO', startTimePreICO);
}
function stopSale() onlyOwner public {
require(startTimeICO > 0 || startTimePreICO > 0);
if (startTimeICO > 0){
SaleStatus('ICO stopped', now);
}
else{
multisigPreICO.transfer(capPreICO);
capPreICOTrasferred = capPreICOTrasferred.add(capPreICO);
capPreICO = 0;
SaleStatus('Pre ICO stopped', now);
}
startTimeICO = 0;
startTimePreICO = 0;
startTimePrivatePreICO = 0;
}
function currentBonusPercent() public constant returns(uint256 bonus_percent) {
require(startTimeICO > 0 || startTimePreICO > 0);
uint256 current_date = now;
uint256 bonusPercent = 0;
if (startTimeICO > 0){
if (current_date > startTimeICO && current_date <= (startTimeICO.add(1 weeks))){ bonusPercent = ICOBonusPercent1week; }
else{
if (current_date > startTimeICO && current_date <= (startTimeICO.add(2 weeks))){ bonusPercent = ICOBonusPercent2week; }
else{
if (current_date > startTimeICO && current_date <= (startTimeICO.add(3 weeks))){ bonusPercent = ICOBonusPercent3week; }
}
}
}
else{
if(startTimePrivatePreICO > 0) {
bonusPercent = privatePreICOBonusPercent;
}
else {
bonusPercent = preICOBonusPercent;
}
}
return bonusPercent;
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function() payable public {
require(startTimeICO > 0 || startTimePreICO > 0);
require(msg.sender != address(0));
require(msg.value > 0);
require(cap < hardCap);
uint256 bonusPercent = currentBonusPercent();
uint256 currentPrice = price.mul(100 - bonusPercent).div(100);
address depositor = msg.sender;
uint256 deposit = msg.value;
uint256 tokens = deposit/currentPrice;
if (startTimeICO > 0){
require(soldTokenCount.add(tokens) <= maxPreICOandICOSupply);
}
else{
if(startTimePrivatePreICO > 0) {
tokens = (tokens * (100 + privatePreICOFreeBonusPercent)) / 100;
}
else {
tokens = (tokens * (100 + preICOFreeBonusPercent)) / 100;
}
require(soldTokenCount.add(tokens) <= maxPreICOSupply);
}
balances[owner] = balances[owner].sub(tokens);
balances[depositor] = balances[depositor].add(tokens);
soldTokenCount = soldTokenCount.add(tokens);
if (startTimeICO > 0){
ICObalances[depositor] = ICObalances[depositor].add(tokens);
}
if (startTimeICO > 0){
ICOdepositors[depositor] = ICOdepositors[depositor].add(deposit);
}
else{
if(startTimePrivatePreICO > 0) {
privatePreICOdepositors[depositor] = privatePreICOdepositors[depositor].add(deposit);
}
else {
preICOdepositors[depositor] = preICOdepositors[depositor].add(deposit);
}
}
cap = cap.add(deposit);
if(startTimePreICO > 0) {
capPreICO = capPreICO.add(deposit);
}
capFiatAndETH = capFiat.add(cap);
if(capFiatAndETH >= softCap) {
capReached = true;
}
TokenPurchase(owner, depositor, deposit, tokens);
}
event ExtTokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
function extBuyTokens(address beneficiary_, uint256 tokensAmount_, uint256 amountETH_) public {
require(startTimeICO > 0 || startTimePreICO > 0);
require(msg.sender != address(0));
require(msg.sender == extOwner);
address depositor = beneficiary_;
uint256 tokens = tokensAmount_;
uint256 amountETH = amountETH_;
balances[owner] = balances[owner].sub(tokens);
balances[depositor] = balances[depositor].add(tokens);
soldTokenCount = soldTokenCount.add(tokens);
capFiat = capFiat.add(amountETH);
capFiatAndETH = capFiat.add(cap);
if(capFiatAndETH >= softCap) {
capReached = true;
}
ExtTokenPurchase(owner, depositor, tokens);
}
function transferExtOwnership(address newOwner_) onlyOwner public {
extOwner = newOwner_;
}
bool public refundCompleted = false;
uint256 public startTimeRefund = 0;
function startRefund() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimeRefund = now;
SaleStatus('Refund started', startTimeRefund);
}
function stopRefund() onlyOwner public {
require(startTimeRefund > 0);
startTimeRefund = 0;
refundCompleted = true;
SaleStatus('Refund stopped', now);
}
event Refunded(address indexed depositor, uint256 indexed deposit, uint256 indexed tokens);
function refund() public {
require(capFiatAndETH < softCap);
require(startTimeRefund > 0);
address depositor = msg.sender;
uint256 deposit = ICOdepositors[depositor];
uint256 tokens = ICObalances[depositor];
ICOdepositors[depositor] = 0;
ICObalances[depositor] = 0;
balances[depositor] = balances[depositor].sub(tokens);
depositor.transfer(deposit);
balances[owner] = balances[owner].add(tokens);
cap = cap.sub(deposit);
capFiatAndETH = capFiatAndETH.sub(deposit);
soldTokenCount = soldTokenCount.sub(tokens);
Refunded(depositor, deposit, tokens);
}
bool public fixSaleCompleted = false;
function fixSale() onlyOwner public {
require(refundCompleted == true);
require(startTimeICO == 0 && startTimePreICO == 0 && startTimeRefund == 0);
require(multisig != address(0));
uint256 restrictedTokens = soldTokenCount * (totalSupply - maxPreICOandICOSupply) / maxPreICOandICOSupply;
transfer(multisig, restrictedTokens);
multisig.transfer(cap.sub(capPreICOTrasferred));
soldTokenCount = 0;
fixSaleCompleted = true;
}
event Burn(address indexed burner, uint indexed value);
function burn(uint _value) onlyOwner public {
require(fixSaleCompleted == true);
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
refundCompleted = false;
fixSaleCompleted = false;
Burn(burner, _value);
}
string constant public name = "FUELD";
string constant public symbol = "FLD";
uint32 constant public decimals = 18;
function FueldToken() public {
owner = msg.sender;
balances[owner] = totalSupply;
}
}
| 165,552 | 0 |
4addd10ff838b4b06774035b9479473f7516105db0d30db481dd1500038c88cb
| 21,348 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xf2a7c7f3932efcc2ecb6b2c372b84030de191db0.sol
| 3,345 | 12,231 |
pragma solidity 0.4.19;
// File: node_modules/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: node_modules/zeppelin-solidity/contracts/ownership/Claimable.sol
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);
}
}
// File: node_modules/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: node_modules/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: node_modules/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: node_modules/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: node_modules/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: node_modules/zeppelin-solidity/contracts/token/ERC827/ERC827.sol
contract ERC827 is ERC20 {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC827/ERC827Token.sol
contract ERC827Token is ERC827, StandardToken {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
return true;
}
}
// File: contracts/BaseContracts/SDABasicToken.sol
contract SDABasicToken is ERC827Token, Claimable {
mapping (address => bool) public isHolder;
address[] public holders;
function addHolder(address _addr) internal returns (bool) {
if (isHolder[_addr] != true) {
holders[holders.length++] = _addr;
isHolder[_addr] = true;
return true;
}
return false;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transfer(_to, _value);
addHolder(_to);
return ok;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transferFrom(_from, _to, _value);
addHolder(_to);
return ok;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transfer(_to, _value, _data);
addHolder(_to);
return ok;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transferFrom(_from, _to, _value, _data);
addHolder(_to);
return ok;
}
}
// File: contracts/BaseContracts/SDABurnableToken.sol
/// SDA Burnable Token Contract
/// SDA Burnable Token Contract is based on Open Zeppelin
/// and modified
contract SDABurnableToken is SDABasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public onlyOwner {
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);
Transfer(burner, address(0), _value);
}
}
// File: contracts/BaseContracts/SDAMigratableToken.sol
contract MigrationAgent {
function migrateFrom(address from, uint256 value) public returns (bool);
}
contract SDAMigratableToken is SDABasicToken {
using SafeMath for uint256;
address public migrationAgent;
uint256 public migrationCountComplete;
event Migrate(address indexed owner, uint256 value);
function setMigrationAgent(address agent) public onlyOwner {
migrationAgent = agent;
}
function migrate() public returns (bool) {
require(migrationAgent != address(0));
uint256 value = balances[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply_ = totalSupply_.sub(value);
MigrationAgent(migrationAgent).migrateFrom(msg.sender, value);
Migrate(msg.sender, value);
return true;
}
function migrateHolders(uint256 count) public onlyOwner returns (bool) {
require(count > 0);
require(migrationAgent != address(0));
count = migrationCountComplete + count;
if (count > holders.length) {
count = holders.length;
}
for (uint256 i = migrationCountComplete; i < count; i++) {
address holder = holders[i];
uint256 value = balances[holder];
balances[holder] = balances[holder].sub(value);
totalSupply_ = totalSupply_.sub(value);
MigrationAgent(migrationAgent).migrateFrom(holder, value);
Migrate(holder, value);
return true;
}
}
}
// File: contracts/BaseContracts/SDAMintableToken.sol
/// SDA Mintable Token Contract
/// @notice SDA Mintable Token Contract is based on Open Zeppelin
/// and modified
contract SDAMintableToken is SDABasicToken {
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/SDAToken.sol
// ----------------------------------------------------------------------------
// SDA token contract
//
// Symbol : SDA
// Name : Secondary Data Attestation Token
// Total supply : 1,000,000,000.000000000000000000
// Decimals : 18
//
// ----------------------------------------------------------------------------
contract SDAToken is SDAMintableToken, SDABurnableToken, SDAMigratableToken {
string public name;
string public symbol;
uint8 public decimals;
function SDAToken() public {
name = "Secondary Data Attestation Token";
symbol = "SEDA";
decimals = 18;
totalSupply_ = 1000000000 * 10 ** uint(decimals);
balances[owner] = totalSupply_;
Transfer(address(0), owner, totalSupply_);
}
function() public payable {
revert();
}
}
| 147,926 | 1 |
7a9e85e8d75ccb41352d4915c3ea6eccbffa83068a0dc80ef0f5dad0ea8fcf41
| 29,901 |
.sol
|
Solidity
| false |
481422385
|
helix-bridge/contracts
|
9502f23dac3178911f8211f4dde3160ec97c7a6d
|
helix-contract/flatten/sub2eth/TransparentUpgradeableProxy.sol
| 3,316 | 13,167 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// File @zeppelin-solidity/contracts/proxy/Proxy.sol@v4.7.3
// License-Identifier: MIT
// 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 {}
}
// File @zeppelin-solidity/contracts/interfaces/draft-IERC1822.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// File @zeppelin-solidity/contracts/proxy/beacon/IBeacon.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// File @zeppelin-solidity/contracts/utils/Address.sol@v4.7.3
// License-Identifier: MIT
// 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);
}
}
}
}
// File @zeppelin-solidity/contracts/utils/StorageSlot.sol@v4.7.3
// License-Identifier: MIT
// 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
}
}
}
// File @zeppelin-solidity/contracts/proxy/ERC1967/ERC1967Upgrade.sol@v4.7.3
// License-Identifier: MIT
// 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);
}
}
}
// File @zeppelin-solidity/contracts/proxy/ERC1967/ERC1967Proxy.sol@v4.7.3
// License-Identifier: MIT
// 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();
}
}
// File @zeppelin-solidity/contracts/proxy/transparent/TransparentUpgradeableProxy.sol@v4.7.3
// License-Identifier: MIT
// 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();
}
}
// File contracts/mapping-token/deprecated/proxy.sol
// License-Identifier: MIT
| 235,532 | 2 |
b03bc9d5e596dd5470dafbc396f81c04600cdf95b1a293b1e1539d52cc294b90
| 17,200 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xe4c577bdec9ce0f6c54f2f82aed5b1913b71ae2f.sol
| 3,544 | 13,565 |
pragma solidity ^0.5.0;
interface IGST2 {
function freeUpTo(uint256 value) external returns (uint256 freed);
function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
function balanceOf(address who) external view returns (uint256);
}
library ExternalCall {
// Source: https://github.com/gnosis/MultiSigWallet/blob/master/contracts/MultiSigWallet.sol
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function externalCall(address destination, uint value, bytes memory data, uint dataOffset, uint dataLength) internal returns(bool result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
add(d, dataOffset),
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
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;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
contract TokenSpender is Ownable {
using SafeERC20 for IERC20;
function claimTokens(IERC20 token, address who, address dest, uint256 amount) external onlyOwner {
token.safeTransferFrom(who, dest, amount);
}
}
contract AggregatedTokenSwap {
using SafeERC20 for IERC20;
using SafeMath for uint;
using ExternalCall for address;
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
TokenSpender public spender;
IGST2 gasToken;
address payable owner;
uint fee; // 10000 => 100%, 1 => 0.01%
event OneInchFeePaid(IERC20 indexed toToken,
address indexed referrer,
uint256 fee);
modifier onlyOwner {
require(msg.sender == owner,
"Only owner can call this function.");
_;
}
constructor(address payable _owner,
IGST2 _gasToken,
uint _fee)
public
{
spender = new TokenSpender();
owner = _owner;
gasToken = _gasToken;
fee = _fee;
}
function setFee(uint _fee) public onlyOwner {
fee = _fee;
}
function aggregate(IERC20 fromToken,
IERC20 toToken,
uint tokensAmount,
address[] memory callAddresses,
bytes memory callDataConcat,
uint[] memory starts,
uint[] memory values,
uint mintGasPrice,
uint minTokensAmount,
address payable referrer)
public
payable
returns (uint returnAmount)
{
returnAmount = gasleft();
uint gasTokenBalance = gasToken.balanceOf(address(this));
require(callAddresses.length + 1 == starts.length);
if (address(fromToken) != ETH_ADDRESS) {
spender.claimTokens(fromToken, msg.sender, address(this), tokensAmount);
}
for (uint i = 0; i < starts.length - 1; i++) {
if (starts[i + 1] - starts[i] > 0) {
if (address(fromToken) != ETH_ADDRESS &&
fromToken.allowance(address(this), callAddresses[i]) == 0) {
fromToken.safeApprove(callAddresses[i], uint256(- 1));
}
require(callDataConcat[starts[i] + 0] != spender.claimTokens.selector[0] ||
callDataConcat[starts[i] + 1] != spender.claimTokens.selector[1] ||
callDataConcat[starts[i] + 2] != spender.claimTokens.selector[2] ||
callDataConcat[starts[i] + 3] != spender.claimTokens.selector[3]);
require(callAddresses[i].externalCall(values[i], callDataConcat, starts[i], starts[i + 1] - starts[i]));
}
}
if (address(toToken) == ETH_ADDRESS) {
require(address(this).balance >= minTokensAmount);
} else {
require(toToken.balanceOf(address(this)) >= minTokensAmount);
}
//
require(gasTokenBalance == gasToken.balanceOf(address(this)));
if (mintGasPrice > 0) {
audoRefundGas(returnAmount, mintGasPrice);
}
//
returnAmount = _balanceOf(toToken, address(this)) * fee / 10000;
if (referrer != address(0)) {
returnAmount /= 2;
if (!_transfer(toToken, referrer, returnAmount, true)) {
returnAmount *= 2;
emit OneInchFeePaid(toToken, address(0), returnAmount);
} else {
emit OneInchFeePaid(toToken, referrer, returnAmount / 2);
}
}
_transfer(toToken, owner, returnAmount, false);
returnAmount = _balanceOf(toToken, address(this));
_transfer(toToken, msg.sender, returnAmount, false);
}
function _balanceOf(IERC20 token, address who) internal view returns(uint256) {
if (address(token) == ETH_ADDRESS || token == IERC20(0)) {
return who.balance;
} else {
return token.balanceOf(who);
}
}
function _transfer(IERC20 token, address payable to, uint256 amount, bool allowFail) internal returns(bool) {
if (address(token) == ETH_ADDRESS || token == IERC20(0)) {
if (allowFail) {
return to.send(amount);
} else {
to.transfer(amount);
return true;
}
} else {
token.safeTransfer(to, amount);
return true;
}
}
function audoRefundGas(uint startGas,
uint mintGasPrice)
private
returns (uint freed)
{
uint MINT_BASE = 32254;
uint MINT_TOKEN = 36543;
uint FREE_BASE = 14154;
uint FREE_TOKEN = 6870;
uint REIMBURSE = 24000;
uint tokensAmount = ((startGas - gasleft()) + FREE_BASE) / (2 * REIMBURSE - FREE_TOKEN);
uint maxReimburse = tokensAmount * REIMBURSE;
uint mintCost = MINT_BASE + (tokensAmount * MINT_TOKEN);
uint freeCost = FREE_BASE + (tokensAmount * FREE_TOKEN);
uint efficiency = (maxReimburse * 100 * tx.gasprice) / (mintCost * mintGasPrice + freeCost * tx.gasprice);
if (efficiency > 100) {
return refundGas(tokensAmount);
} else {
return 0;
}
}
function refundGas(uint tokensAmount)
private
returns (uint freed)
{
if (tokensAmount > 0) {
uint safeNumTokens = 0;
uint gas = gasleft();
if (gas >= 27710) {
safeNumTokens = (gas - 27710) / (1148 + 5722 + 150);
}
if (tokensAmount > safeNumTokens) {
tokensAmount = safeNumTokens;
}
uint gasTokenBalance = IERC20(address(gasToken)).balanceOf(address(this));
if (tokensAmount > 0 && gasTokenBalance >= tokensAmount) {
return gasToken.freeUpTo(tokensAmount);
} else {
return 0;
}
} else {
return 0;
}
}
function() external payable {
if (msg.value == 0 && msg.sender == owner) {
IERC20 _gasToken = IERC20(address(gasToken));
owner.transfer(address(this).balance);
_gasToken.safeTransfer(owner, _gasToken.balanceOf(address(this)));
}
}
}
| 211,349 | 3 |
59c0556ba3b16e3a88f7954b060ce9d75c57f57c6aa510799c5301a115c2168c
| 11,636 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9b041285587b701b703cbb40256558f0f3b94ed3.sol
| 3,061 | 10,965 |
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 Ownable {
address public owner;
function Ownable() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(owner==msg.sender);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract ERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CBITToken is Ownable, ERC20 {
using SafeMath for uint256;
// Token properties
string public name = "CAMBITUS";
string public symbol = "CBIT";
uint256 public decimals = 18;
uint256 public _totalSupply = 250000000e18;
uint256 public _icoSupply = 156250000e18; //62.5%
uint256 public _preSaleSupply = 43750000e18; //17.5%
uint256 public _phase1Supply = 50000000e18; //20%
uint256 public _phase2Supply = 50000000e18; //20%
uint256 public _finalSupply = 12500000e18; //5%
uint256 public _teamSupply = 43750000e18; //17.5%
uint256 public _communitySupply = 12500000e18; //5%
uint256 public _bountySupply = 12500000e18; //5%
uint256 public _ecosysSupply = 25000000e18; //10%
// 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;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
// Wallet Address of Token
address public multisig;
// how many token units a buyer gets per wei
uint256 public price;
uint256 public minContribAmount = 1 ether;
uint256 public maxCap = 81000 ether;
uint256 public minCap = 450 ether;
//number of total tokens sold
uint256 public totalNumberTokenSold=0;
bool public tradable = false;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier canTradable() {
require(tradable || (now > startTime + 180 days));
_;
}
// Constructor
// @notice CBITToken Contract
// @return the transaction address
function CBITToken() public{
multisig = 0xAfC252F597bd592276C6846cD44d1F82d87e63a2;
balances[multisig] = _totalSupply;
startTime = 1525150800;
owner = msg.sender;
}
// Payable method
// @notice Anyone can buy the tokens on tokensale by paying ether
function () external payable {
tokensale(msg.sender);
}
// @notice tokensale
// @param recipient The address of the recipient
// @return the transaction address and send the event as Transfer
function tokensale(address recipient) public payable {
require(recipient != 0x0);
require(msg.value >= minContribAmount);
price = getPrice();
uint256 weiAmount = msg.value;
uint256 tokenToSend = weiAmount.mul(price);
require(tokenToSend > 0);
require(_icoSupply >= tokenToSend);
balances[multisig] = balances[multisig].sub(tokenToSend);
balances[recipient] = balances[recipient].add(tokenToSend);
totalNumberTokenSold=totalNumberTokenSold.add(tokenToSend);
_icoSupply = _icoSupply.sub(tokenToSend);
multisig.transfer(msg.value);
TokenPurchase(msg.sender, recipient, weiAmount, tokenToSend);
}
// Token distribution to Team
function sendICOSupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _icoSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
_icoSupply = _icoSupply.sub(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
Transfer(multisig, to, value);
}
// Token distribution to Team
function sendTeamSupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _teamSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_teamSupply = _teamSupply.sub(value);
Transfer(multisig, to, value);
}
// Token distribution to Community
function sendCommunitySupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _communitySupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_communitySupply = _communitySupply.sub(value);
Transfer(multisig, to, value);
}
// Token distribution to Bounty
function sendBountySupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _bountySupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_bountySupply = _bountySupply.sub(value);
Transfer(multisig, to, value);
}
// Token distribution to Ecosystem
function sendEcosysSupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _ecosysSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_ecosysSupply = _ecosysSupply.sub(value);
Transfer(multisig, to, value);
}
// Start or pause tradable to Transfer token
function startTradable(bool _tradable) public onlyOwner {
tradable = _tradable;
}
// @return total tokens supplied
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
// @return total tokens supplied
function totalNumberTokenSold() public view returns (uint256) {
return totalNumberTokenSold;
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balanace the particular account
function balanceOf(address who) public constant returns (uint256) {
return balances[who];
}
// @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 the transaction address and send the event as Transfer
function transfer(address to, uint256 value) public canTradable returns (bool success) {
require (balances[msg.sender] >= value && value > 0);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
return true;
}
// @notice send `value` token to `to` from `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 the transaction address and send the event as Transfer
function transferFrom(address from, address to, uint256 value) public canTradable returns (bool success) {
require (allowed[from][msg.sender] >= value && balances[from] >= value && value > 0);
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;
}
// Allow spender to withdraw from your account, multiple times, up to the value amount.
// If this function is called again it overwrites the current allowance with value.
// @param spender The address of the sender
// @param value The amount to be approved
// @return the transaction address and send the event as Approval
function approve(address spender, uint256 value) public returns (bool success) {
require (balances[msg.sender] >= value && value > 0);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
return true;
}
// Check the allowed value for the spender to withdraw from owner
// @param owner The address of the owner
// @param spender The address of the spender
// @return the amount which spender is still allowed to withdraw from owner
function allowance(address _owner, address spender) public constant returns (uint256) {
return allowed[_owner][spender];
}
// Get current price of a Token
// @return the price or token value for a ether
function getPrice() public view returns (uint result) {
if ((now < startTime + 30 days) && (totalNumberTokenSold < _preSaleSupply)) {
return 7500;
} else if ((now < startTime + 60 days) && (totalNumberTokenSold < _preSaleSupply + _phase1Supply)) {
return 5000;
} else if ((now < startTime + 90 days) && (totalNumberTokenSold < _preSaleSupply + _phase1Supply + _phase2Supply)) {
return 3125;
} else if ((now < startTime + 99 days) && (totalNumberTokenSold < _preSaleSupply + _phase1Supply + _phase2Supply + _finalSupply)) {
return 1500;
} else {
return 0;
}
}
function getTokenDetail() public view returns (string, string, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (name, symbol, _totalSupply, totalNumberTokenSold, _icoSupply, _teamSupply, _communitySupply, _bountySupply, _ecosysSupply);
}
}
| 217,930 | 4 |
2fa3c65176f84a6ef94a3305fa257188be17509bcad271b280a039cc6efca8e5
| 16,490 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/65/6560051ead959645eeec16cbbf81fecc384ab95a_AVAXNation.sol
| 3,940 | 15,655 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract AVAXNation is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 95,831 | 5 |
cb6610087b741b19108b7bca3de604c243b4a56e256bb6ceda00c97c3df77212
| 12,626 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8fd8599b06a13218e6550f5a77961a201543564c.sol
| 2,690 | 10,277 |
pragma solidity ^0.4.25;
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 TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
totalSupply = 12000000000 * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "DCETHER"; // Set the name for display purposes
symbol = "DCETH"; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
}
contract DCETHER is owned, TokenERC20 {
uint public sale_step;
address dcether_corp;
address public Coin_manager;
mapping (address => address) public followup;
constructor() TokenERC20() public
{
sale_step = 0; // 0 : No sale, 1 : Presale, 2 : Crowdsale, 3 : Normalsale
dcether_corp = msg.sender;
Coin_manager = 0x0;
}
function SetCoinManager(address manager) onlyOwner public
{
require(manager != 0x0);
uint amount = balanceOf[dcether_corp];
Coin_manager = manager;
balanceOf[Coin_manager] += amount;
balanceOf[dcether_corp] = 0;
Transfer(dcether_corp, Coin_manager, amount); // execute an event reflecting the change
}
function SetSaleStep(uint256 step) onlyOwner public
{
sale_step = step;
}
function () payable public
{
require(sale_step!=0);
uint nowprice = 10000; // Token Price per ETher
address follower_1st = 0x0; // 1st follower
address follower_2nd = 0x0; // 2nd follower
uint amount = 0; // Total token buyed
uint amount_1st = 0; // Bonus token for 1st follower
uint amount_2nd = 0; // Bonus token for 2nd follower
uint all_amount = 0;
amount = msg.value * nowprice;
follower_1st = followup[msg.sender];
if (follower_1st != 0x0)
{
amount_1st = amount; // 100% bonus give to 1st follower
if (balanceOf[follower_1st] < amount_1st) // if he has smaller than bonus
amount_1st = balanceOf[follower_1st]; // cannot get bonus all
follower_2nd = followup[follower_1st];
if (follower_2nd != 0x0)
{
amount_2nd = amount / 2; // 50% bonus give to 2nd follower
if (balanceOf[follower_2nd] < amount_2nd) // if he has smaller than bonus
amount_2nd = balanceOf[follower_2nd]; // cannot get bonus all
}
}
all_amount = amount + amount_1st + amount_2nd;
address manager = Coin_manager;
if (manager == 0x0)
manager = dcether_corp;
require(balanceOf[manager]>=all_amount);
require(balanceOf[msg.sender] + amount > balanceOf[msg.sender]);
balanceOf[manager] -= amount;
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
require(manager.send(msg.value));
Transfer(this, msg.sender, amount); // execute an event reflecting the change
if (amount_1st > 0) // first follower give bonus
{
require(balanceOf[follower_1st] + amount_1st > balanceOf[follower_1st]);
balanceOf[manager] -= amount_1st;
balanceOf[follower_1st] += amount_1st; // adds the amount to buyer's balance
Transfer(this, follower_1st, amount_1st); // execute an event reflecting the change
}
if (amount_2nd > 0) // second follower give bonus
{
require(balanceOf[follower_2nd] + amount_2nd > balanceOf[follower_2nd]);
balanceOf[manager] -= amount_2nd;
balanceOf[follower_2nd] += amount_2nd; // adds the amount to buyer's balance
Transfer(this, follower_2nd, amount_2nd); // execute an event reflecting the change
}
}
function BuyFromFollower(address follow_who) payable public
{
require(sale_step!=0);
uint nowprice = 10000; // Token Price per ETher
address follower_1st = 0x0; // 1st follower
address follower_2nd = 0x0; // 2nd follower
uint amount = 0; // Total token buyed
uint amount_1st = 0; // Bonus token for 1st follower
uint amount_2nd = 0; // Bonus token for 2nd follower
uint all_amount = 0;
amount = msg.value * nowprice;
follower_1st = follow_who;
followup[msg.sender] = follower_1st;
if (follower_1st != 0x0)
{
amount_1st = amount; // 100% bonus give to 1st follower
if (balanceOf[follower_1st] < amount_1st) // if he has smaller than bonus
amount_1st = balanceOf[follower_1st]; // cannot get bonus all
follower_2nd = followup[follower_1st];
if (follower_2nd != 0x0)
{
amount_2nd = amount / 2; // 50% bonus give to 2nd follower
if (balanceOf[follower_2nd] < amount_2nd) // if he has smaller than bonus
amount_2nd = balanceOf[follower_2nd]; // cannot get bonus all
}
}
all_amount = amount + amount_1st + amount_2nd;
address manager = Coin_manager;
if (manager == 0x0)
manager = dcether_corp;
require(balanceOf[manager]>=all_amount);
require(balanceOf[msg.sender] + amount > balanceOf[msg.sender]);
balanceOf[manager] -= amount;
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
require(manager.send(msg.value));
Transfer(this, msg.sender, amount); // execute an event reflecting the change
if (amount_1st > 0) // first follower give bonus
{
require(balanceOf[follower_1st] + amount_1st > balanceOf[follower_1st]);
balanceOf[manager] -= amount_1st;
balanceOf[follower_1st] += amount_1st; // adds the amount to buyer's balance
Transfer(this, follower_1st, amount_1st); // execute an event reflecting the change
}
if (amount_2nd > 0) // second follower give bonus
{
require(balanceOf[follower_2nd] + amount_2nd > balanceOf[follower_2nd]);
balanceOf[manager] -= amount_2nd;
balanceOf[follower_2nd] += amount_2nd; // adds the amount to buyer's balance
Transfer(this, follower_2nd, amount_2nd); // execute an event reflecting the change
}
}
function ForceCoinTransfer(address _from, address _to, uint amount) onlyOwner public
{
uint coin_amount = amount * 10 ** uint256(decimals);
require(_from != 0x0);
require(_to != 0x0);
require(balanceOf[_from] >= coin_amount); // checks if the sender has enough to sell
balanceOf[_from] -= coin_amount; // subtracts the amount from seller's balance
balanceOf[_to] += coin_amount; // subtracts the amount from seller's balance
Transfer(_from, _to, coin_amount); // executes an event reflecting on the change
}
function DestroyCoin(address _from, uint256 coin_amount) onlyOwner public
{
uint256 amount = coin_amount * 10 ** uint256(decimals);
require(balanceOf[_from] >= amount); // checks if the sender has enough to sell
balanceOf[_from] -= amount; // subtracts the amount from seller's balance
Transfer(_from, this, amount); // executes an event reflecting on the change
}
}
| 217,526 | 6 |
572635e0ddb274e2b30d9cd81791a3da909a2d05779900a7f31b0c0ceddd42d7
| 28,967 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xF6cEb88BC891051eDbfDa5D7cf1fB88fd7d78eaC/contract.sol
| 5,103 | 18,269 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TestToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'TestToken';
string private constant _symbol = 'TEST';
uint256 private _taxFee = 180;
uint256 private _burnFee = 220;
uint private _max_tx_size = 100000000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 250,015 | 7 |
dcd322eaa50e6064dd04b5ccea30055458af33dcfde16495200392c9c6b37b35
| 18,468 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x904afb631a24881d8af2ef57dce1e9d6f117dcb6.sol
| 2,820 | 10,293 |
pragma solidity ^0.4.25;
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;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract MLM_FOMO_BANK is Ownable {
using SafeMath for uint256;
// time to win FOMO bank
uint public fomo_period = 3600; // 1 hour
// FOMO bank balance
uint public balance;
// next winner address
address public winner;
// win time
uint public finish_time;
// MLM contract
address _mlm;
// only MLM contract can call method
modifier onlyMLM() {
require(msg.sender == _mlm);
_;
}
event Win(address indexed user, uint amount);
function SetMLM(address mlm) public onlyOwner {
_mlm = mlm;
}
// fill the bank
function AddToBank(address user) public payable onlyMLM {
// check for winner
CheckWinner();
// save last payment info
balance = balance.add(msg.value);
winner = user;
finish_time = now + fomo_period;
}
// check winner
function CheckWinner() internal {
if(now > finish_time && winner != address(0)){
emit Win(winner, balance);
// it should not be reentrancy, but just in case
uint prev_balance = balance;
balance = 0;
// send ethers to winner
winner.transfer(prev_balance);
winner = address(0);
}
}
// get cuurent FOMO info {balance, finish_time, winner }
function GetInfo() public view returns (uint, uint, address) {
return (balance,
finish_time,
winner);
}
}
contract MLM is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
// FOMO bank contract
MLM_FOMO_BANK _fomo;
struct userStruct {
address[] referrers; // array with 3 level referrers
address[] referrals; // array with referrals
uint next_payment; // time to next payments, seconds
bool isRegitered; // is user registered
bytes32 ref_link; // referral link
}
// mapping with users
mapping(address=>userStruct) users;
// mapping with referral links
mapping(bytes32=>address) ref_to_users;
uint public min_paymnet = 100 finney; // minimum payment amount 0,1ETH
uint public min_time_to_add = 604800; // Time need to add after miimum payment, seconds | 1 week
uint[] public reward_parts = [35, 25, 15, 15, 10]; // how much need to send to referrers, %
event RegisterEvent(address indexed user, address indexed referrer);
event PayEvent(address indexed payer, uint amount, bool[3] levels);
constructor(MLM_FOMO_BANK fomo) public {
// set FOMO contract
_fomo = fomo;
}
function() public payable {
// sender should not be a contract
require(!address(msg.sender).isContract());
// user should be registered
require(users[msg.sender].isRegitered);
Pay(0x00);
}
function Pay(bytes32 referrer_addr) public payable nonReentrant {
// sender should not be a contract
require(!address(msg.sender).isContract());
// check minimum amount
require(msg.value >= min_paymnet);
// if it is a first payment need to register sender
if(!users[msg.sender].isRegitered){
_register(referrer_addr);
}
uint amount = msg.value;
// what referrer levels will received a payments, need on UI
bool[3] memory levels = [false,false,false];
// iterate of sender's referrers
for(uint i = 0; i < users[msg.sender].referrers.length; i++){
// referrer address at level i
address ref = users[msg.sender].referrers[i];
// if referrer is active need to pay him
if(users[ref].next_payment > now){
// calculate reward part, i.e. 0.1 * 35 / 100 = 0.035
uint reward = amount.mul(reward_parts[i]).div(100);
// send reward to referrer
ref.transfer(reward);
// set referrer's level ad payment
levels[i] = true;
}
}
// what address will be saved to FOMO bank, referrer or current sender
address fomo_user = msg.sender;
if(users[msg.sender].referrers.length>0 && users[users[msg.sender].referrers[0]].next_payment > now)
fomo_user = users[msg.sender].referrers[0];
// send 15% to FOMO bank and store selceted user
_fomo.AddToBank.value(amount.mul(reward_parts[3]).div(100)).gas(gasleft())(fomo_user);
// prolong referral link life
if(now > users[msg.sender].next_payment)
users[msg.sender].next_payment = now.add(amount.mul(min_time_to_add).div(min_paymnet));
else
users[msg.sender].next_payment = users[msg.sender].next_payment.add(amount.mul(min_time_to_add).div(min_paymnet));
emit PayEvent(msg.sender, amount, levels);
}
function _register(bytes32 referrer_addr) internal {
// sender should not be registered
require(!users[msg.sender].isRegitered);
// get referrer address
address referrer = ref_to_users[referrer_addr];
// users could not be a referrer
require(referrer!=msg.sender);
// if there is referrer
if(referrer != address(0)){
// set refferers for currnet user
_setReferrers(referrer, 0);
}
// mark user as registered
users[msg.sender].isRegitered = true;
// calculate referral link
_getReferralLink(referrer);
emit RegisterEvent(msg.sender, referrer);
}
// generate a referral link
function _getReferralLink(address referrer) internal {
do{
users[msg.sender].ref_link = keccak256(abi.encodePacked(uint(msg.sender) ^ uint(referrer) ^ now));
} while(ref_to_users[users[msg.sender].ref_link] != address(0));
ref_to_users[users[msg.sender].ref_link] = msg.sender;
}
// set referrers
function _setReferrers(address referrer, uint level) internal {
// set referrer only for active user other case use his referrer
if(users[referrer].next_payment > now){
users[msg.sender].referrers.push(referrer);
if(level == 0){
// add current user to referrer's referrals list
users[referrer].referrals.push(msg.sender);
}
level++;
}
// set referrers for 3 levels
if(level<3 && users[referrer].referrers.length>0)
_setReferrers(users[referrer].referrers[0], level);
}
function GetUser() public view returns(uint, bool, bytes32) {
return (users[msg.sender].next_payment,
users[msg.sender].isRegitered,
users[msg.sender].ref_link);
}
// Get sender's referrers
function GetReferrers() public view returns(address[] memory) {
return users[msg.sender].referrers;
}
// Get sender's referrals
function GetReferrals() public view returns(address[] memory) {
return users[msg.sender].referrals;
}
// Project's owner can widthdraw contract's balance
function widthdraw(address to, uint amount) public onlyOwner {
to.transfer(amount);
}
}
| 208,455 | 8 |
f49c997c2d12d46bbc5e4b5b8df9e0c0562f44c7718c67bbc5db1fe8ee37d655
| 18,283 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b0/b0bc3210b14b59b8708884884a895d6bd79d9d59_Pot.sol
| 3,153 | 11,796 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library myLibrary {
struct bidPrice {
uint256 bidOption;
uint256 variable1;
uint256 variable2;
}
struct expiryTimeInfo {
uint256 expiryOption;
uint256 startTime;
uint256 decreaseBy;
uint256 minimumTime;
}
struct createPotValue {
address topOwner;
address ownerOfTournament;
address potToken;
uint256 potAmount;
address bidToken;
bidPrice bid;
address[] toAddress;
uint256[] toPercent;
expiryTimeInfo expiryTime;
bool priorityPool;
uint256 toPotFee;
uint256 toPreviousFee;
}
}
contract Pot {
using SafeMath for uint256;
address public potToken;
uint256 public potAmount = 0;
address public bidToken;
uint256 public bidAmount;
bool public priorityPool;
bool public isClaim;
uint256 public createdDate;
uint256 public timeUntilExpiry;
address public ownerOfTournament;
address public lastBidWinner;
uint256 public lengthOfBidDistribution = 0;
uint256 public toOwnerFee = 3;
uint256 public percent = 100;
uint256 public toPotFee;
address public toPreviousBidder;
uint256 public toPreviousBidderFee;
uint256 private winnerClaimAllowTime = 600; // 2851200000; // 33 days
uint256 private createClaimAllowTime = 720; // 5702400000; // 66 days
address public topOwner;
uint256 public bidOption;
uint256 public bidVariable1;
uint256 public bidVariable2;
uint256 public claimedDate;
uint256 public expirationTime;
uint256 public expExpiryOption;
uint256 public expDecreaseBy;
uint256 public expMinimumTime;
IERC20 public _token;
struct bidDistributionInfo {
address toAddress;
uint256 percentage;
}
mapping(uint256 => bidDistributionInfo) public bidInfo;
modifier onlyOwner() {
require(msg.sender == ownerOfTournament, "Not onwer");
_;
}
function setTopOwner(address newTopOwner) public {
require(topOwner == msg.sender, "Error: you can not change Top Owner address!");
topOwner = newTopOwner;
}
function calcBidAmount(uint256 _bidOption, uint256 _variable1, uint256 _variable2) internal {
if(_bidOption == 1) {
bidAmount = _variable1;
} else if (_bidOption == 2) {
bidAmount = potAmount.mul(_variable1).div(percent);
} else if (_bidOption == 3) {
bidAmount = bidAmount + bidAmount.mul(_variable2).div(percent);
}
}
function initialize(myLibrary.createPotValue memory sValue) external {
if (lengthOfBidDistribution > 0) {
require(topOwner == msg.sender, "Error: you can not change initial variable");
}
potToken = sValue.potToken;
bidToken = sValue.bidToken;
_token = IERC20(potToken);
lengthOfBidDistribution = sValue.toAddress.length;
for(uint256 i = 0; i < sValue.toAddress.length; i++) {
bidInfo[i].toAddress = sValue.toAddress[i];
bidInfo[i].percentage = sValue.toPercent[i];
}
priorityPool = sValue.priorityPool;
createdDate = block.timestamp;
timeUntilExpiry = createdDate + sValue.expiryTime.startTime;
expExpiryOption = sValue.expiryTime.expiryOption;
expirationTime = sValue.expiryTime.startTime;
expDecreaseBy = sValue.expiryTime.decreaseBy;
expMinimumTime = sValue.expiryTime.minimumTime;
potAmount += sValue.potAmount;
lastBidWinner = sValue.ownerOfTournament;
toPreviousBidderFee = sValue.toPreviousFee;
ownerOfTournament = sValue.ownerOfTournament;
topOwner = sValue.topOwner;
toPotFee = sValue.toPotFee;
bidOption = sValue.bid.bidOption;
bidVariable1 = sValue.bid.variable1;
bidVariable2 = sValue.bid.variable2;
isClaim = false;
if(bidOption == 1) {
bidAmount = bidVariable1;
} else if (bidOption == 2) {
bidAmount = potAmount.mul(bidVariable1).div(percent);
} else if (bidOption == 3) {
bidAmount = bidVariable1;
}
}
function bid() public payable returns (uint256) {
require(timeUntilExpiry > block.timestamp, "You cannot bid! Because this pot is closed biding!");
require(msg.value > 0, "Insufficinet value");
require(msg.value == bidAmount, "Your bid amount will not exact!");
toPreviousBidder = lastBidWinner;
uint256 value = msg.value;
lastBidWinner = msg.sender;
if(expExpiryOption == 2 && expirationTime > expMinimumTime) {
expirationTime -= expDecreaseBy;
}
uint256 onwerFee = bidAmount.mul(toOwnerFee).div(percent);
payable(address(topOwner)).transfer(onwerFee);
value = value - onwerFee;
uint256 previousBidderFee = bidAmount.mul(toPreviousBidderFee).div(percent);
payable(address(toPreviousBidder)).transfer(previousBidderFee);
value = value - previousBidderFee;
for (uint i = 0; i < lengthOfBidDistribution; i++) {
uint256 bidFee = bidAmount.mul(bidInfo[i].percentage).div(percent);
payable(address(bidInfo[i].toAddress)).transfer(bidFee);
value = value - bidFee;
}
uint256 createdBid = block.timestamp;
timeUntilExpiry = createdBid + expirationTime;
potAmount = address(this).balance;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
return bidAmount;
}
function getLifeTime() public view returns (uint256) {
if(timeUntilExpiry > block.timestamp){
uint256 lifeTime = timeUntilExpiry - block.timestamp;
return lifeTime;
} else {
return 0;
}
}
function claim() public returns (uint256) {
address claimAvailableAddress;
if(block.timestamp < timeUntilExpiry) {
claimAvailableAddress = 0x0000000000000000000000000000000000000000;
} else if (timeUntilExpiry < block.timestamp && block.timestamp < timeUntilExpiry + winnerClaimAllowTime) {
claimAvailableAddress = lastBidWinner;
} else if (timeUntilExpiry + winnerClaimAllowTime < block.timestamp && block.timestamp < timeUntilExpiry + createClaimAllowTime) {
claimAvailableAddress = ownerOfTournament;
} else {
claimAvailableAddress = topOwner;
}
require(msg.sender == claimAvailableAddress, "You cannot claim!");
payable(address(msg.sender)).transfer(address(this).balance);
isClaim = true;
claimedDate = block.timestamp;
return address(this).balance;
}
modifier checkAllowance(uint256 amount) {
require(_token.allowance(msg.sender, address(this)) >= amount, "Allowance Error");
_;
}
function depositToken() external payable {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
uint256 balance = address(msg.sender).balance;
potAmount = msg.value;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20Token(uint256 _amount) external payable checkAllowance(_amount) {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
require(_amount > 0, "Insufficinet value");
_token.transfer(address(this), _amount);
uint256 balance = address(msg.sender).balance;
potAmount = _amount;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20(uint256 _amount) external {
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
require(_amount > 0, "Insufficinet value");
_token.transfer(address(this), _amount);
potAmount = _amount;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
}
}
| 104,802 | 9 |
b032cffe925f77be22a476a16b44d23a552f0ab03f7d8144d6026c3f82a00be0
| 20,181 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0e752b742f744fdc2d93774da44c37b72c3e6952.sol
| 3,226 | 11,856 |
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);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Ownable() public {
owner = msg.sender;
}
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() public onlyOwner whenNotPaused {
paused = true;
Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
Unpause();
}
}
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]);
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 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]);
uint256 _allowance = allowed[_from][msg.sender];
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 view returns (uint256) {
return allowed[_owner][_spender];
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
address public mintAddress;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier onlyMint() {
require(msg.sender == mintAddress);
_;
}
function setMintAddress(address _mintAddress) public onlyOwner {
require(_mintAddress != address(0));
mintAddress = _mintAddress;
}
function mint(address _to, uint256 _amount) public onlyMint canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyMint canMint returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract TokenTimelock {
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.transfer(beneficiary, amount);
}
}
contract CraftyCrowdsale is Pausable {
using SafeMath for uint256;
// Amount received from each address
mapping(address => uint256) received;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public preSaleStart;
uint256 public preSaleEnd;
uint256 public saleStart;
uint256 public saleEnd;
// amount of tokens sold
uint256 public issuedTokens = 0;
// token cap
uint256 public constant hardCap = 5000000000 * 10**8; // 50%
// token wallets
uint256 constant teamCap = 1450000000 * 10**8; // 14.5%
uint256 constant advisorCap = 450000000 * 10**8; // 4.5%
uint256 constant bountyCap = 100000000 * 10**8; // 1%
uint256 constant fundCap = 3000000000 * 10**8; // 30%
// Number of days the tokens will be locked
uint256 constant lockTime = 180 days;
// wallets
address public etherWallet;
address public teamWallet;
address public advisorWallet;
address public fundWallet;
address public bountyWallet;
// timelocked tokens
TokenTimelock teamTokens;
uint256 public rate;
enum State { BEFORE_START, SALE, REFUND, CLOSED }
State currentState = State.BEFORE_START;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
event Refund(address indexed to, uint256 amount);
modifier saleIsOn() {
require(((now >= preSaleStart && now < preSaleEnd) ||
(now >= saleStart && now < saleEnd)) &&
issuedTokens < hardCap &&
currentState == State.SALE);
_;
}
modifier beforeSale() {
require(now < preSaleStart);
_;
}
modifier inState(State _state) {
require(currentState == _state);
_;
}
function CraftyCrowdsale(address _token, uint256 _preSaleStart, uint256 _preSaleEnd, uint256 _saleStart, uint256 _saleEnd, uint256 _rate) public {
require(_token != address(0));
require(_preSaleStart < _preSaleEnd && _preSaleEnd < _saleStart && _saleStart < _saleEnd);
require(_rate > 0);
token = MintableToken(_token);
preSaleStart = _preSaleStart;
preSaleEnd = _preSaleEnd;
saleStart = _saleStart;
saleEnd = _saleEnd;
rate = _rate;
}
function () public payable {
if(msg.sender != owner)
buyTokens();
}
function buyTokens() public saleIsOn whenNotPaused payable {
require(msg.sender != address(0));
require(msg.value >= 20 finney);
uint256 weiAmount = msg.value;
uint256 currentRate = getRate(weiAmount);
// calculate token amount to be created
uint256 newTokens = weiAmount.mul(currentRate).div(10**18);
require(issuedTokens.add(newTokens) <= hardCap);
issuedTokens = issuedTokens.add(newTokens);
received[msg.sender] = received[msg.sender].add(weiAmount);
token.mint(msg.sender, newTokens);
TokenPurchase(msg.sender, msg.sender, newTokens);
etherWallet.transfer(msg.value);
}
function setRate(uint256 _rate) public onlyOwner beforeSale {
require(_rate > 0);
rate = _rate;
}
function setWallets(address _etherWallet, address _teamWallet, address _advisorWallet, address _bountyWallet, address _fundWallet) public onlyOwner inState(State.BEFORE_START) {
require(_etherWallet != address(0));
require(_teamWallet != address(0));
require(_advisorWallet != address(0));
require(_bountyWallet != address(0));
require(_fundWallet != address(0));
etherWallet = _etherWallet;
teamWallet = _teamWallet;
advisorWallet = _advisorWallet;
bountyWallet = _bountyWallet;
fundWallet = _fundWallet;
uint256 releaseTime = saleEnd + lockTime;
// Mint locked tokens
teamTokens = new TokenTimelock(token, teamWallet, releaseTime);
token.mint(teamTokens, teamCap);
// Mint released tokens
token.mint(advisorWallet, advisorCap);
token.mint(bountyWallet, bountyCap);
token.mint(fundWallet, fundCap);
currentState = State.SALE;
}
function generateTokens(address beneficiary, uint256 newTokens) public onlyOwner {
require(beneficiary != address(0));
require(newTokens > 0);
require(issuedTokens.add(newTokens) <= hardCap);
issuedTokens = issuedTokens.add(newTokens);
token.mint(beneficiary, newTokens);
TokenPurchase(msg.sender, beneficiary, newTokens);
}
function finishCrowdsale() public onlyOwner inState(State.SALE) {
require(now > saleEnd);
// tokens not sold to fund
uint256 unspentTokens = hardCap.sub(issuedTokens);
token.mint(fundWallet, unspentTokens);
currentState = State.CLOSED;
token.finishMinting();
}
function enableRefund() public onlyOwner inState(State.CLOSED) {
currentState = State.REFUND;
}
function receivedFrom(address beneficiary) public view returns (uint256) {
return received[beneficiary];
}
function claimRefund() public whenNotPaused inState(State.REFUND) {
require(received[msg.sender] > 0);
uint256 amount = received[msg.sender];
received[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
function releaseTeamTokens() public {
teamTokens.release();
}
function reclaimEther() public onlyOwner {
owner.transfer(this.balance);
}
function getRate(uint256 amount) internal view returns (uint256) {
if(now < preSaleEnd) {
require(amount >= 6797 finney);
if(amount <= 8156 finney)
return rate.mul(105).div(100);
if(amount <= 9515 finney)
return rate.mul(1055).div(1000);
if(amount <= 10874 finney)
return rate.mul(1065).div(1000);
if(amount <= 12234 finney)
return rate.mul(108).div(100);
if(amount <= 13593 finney)
return rate.mul(110).div(100);
if(amount <= 27185 finney)
return rate.mul(113).div(100);
if(amount > 27185 finney)
return rate.mul(120).div(100);
}
return rate;
}
}
| 218,093 | 10 |
8292e2e5b97a9147ef6e2774e3ac94641c6488d549e9271c039feafcbb0cc1b7
| 11,963 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/507_179128_0x090185f2135308bad17527004364ebcc2d37e5f6.sol
| 3,110 | 11,230 |
// SPDX-License-Identifier: MIT
// .d8888b. 888 888
// d88P Y88b 888 888
// Y88b. 888 888
// "Y888b. 88888b. .d88b. 888 888
// "Y88b. 888 "88b d8P Y8b 888 888
// "888 888 888 88888888 888 888
// Y88b d88P 888 d88P Y8b. 888 888
// "Y8888P" 88888P" "Y8888 888 888
// 888
// 888
// 888
// Special thanks to:
// @BoringCrypto for his great libraries @ https://github.com/boringcrypto/BoringSolidity
pragma solidity 0.6.12;
// Contract: BoringOwnable
// Audit on 5-Jan-2021 by Keno and BoringCrypto
// Edited by BoringCrypto
contract BoringOwnableData {
address public owner;
address public pendingOwner;
}
contract BoringOwnable is BoringOwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() public {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
contract Domain {
bytes32 private constant DOMAIN_SEPARATOR_SIGNATURE_HASH = keccak256("EIP712Domain(uint256 chainId,address verifyingContract)");
// See https://eips.ethereum.org/EIPS/eip-191
string private constant EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA = "\x19\x01";
// solhint-disable var-name-mixedcase
bytes32 private immutable _DOMAIN_SEPARATOR;
uint256 private immutable DOMAIN_SEPARATOR_CHAIN_ID;
/// @dev Calculate the DOMAIN_SEPARATOR
function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) {
return keccak256(abi.encode(DOMAIN_SEPARATOR_SIGNATURE_HASH,
chainId,
address(this)));
}
constructor() public {
uint256 chainId; assembly {chainId := chainid()}
_DOMAIN_SEPARATOR = _calculateDomainSeparator(DOMAIN_SEPARATOR_CHAIN_ID = chainId);
}
/// @dev Return the DOMAIN_SEPARATOR
// with the desired public name, such as DOMAIN_SEPARATOR or domainSeparator.
// solhint-disable-next-line func-name-mixedcase
function _domainSeparator() internal view returns (bytes32) {
uint256 chainId; assembly {chainId := chainid()}
return chainId == DOMAIN_SEPARATOR_CHAIN_ID ? _DOMAIN_SEPARATOR : _calculateDomainSeparator(chainId);
}
function _getDigest(bytes32 dataHash) internal view returns (bytes32 digest) {
digest =
keccak256(abi.encodePacked(EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA,
_domainSeparator(),
dataHash));
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/// @notice EIP 2612
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
}
// Data part taken out for building of contracts that receive delegate calls
contract ERC20Data {
/// @notice owner > balance mapping.
mapping(address => uint256) public balanceOf;
/// @notice owner > spender > allowance mapping.
mapping(address => mapping(address => uint256)) public allowance;
/// @notice owner > nonce mapping. Used in `permit`.
mapping(address => uint256) public nonces;
}
abstract contract ERC20 is IERC20, Domain {
/// @notice owner > balance mapping.
mapping(address => uint256) public override balanceOf;
/// @notice owner > spender > allowance mapping.
mapping(address => mapping(address => uint256)) public override allowance;
/// @notice owner > nonce mapping. Used in `permit`.
mapping(address => uint256) public nonces;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/// @notice Transfers `amount` tokens from `msg.sender` to `to`.
/// @param to The address to move the tokens.
/// @param amount of the tokens to move.
/// @return (bool) Returns True if succeeded.
function transfer(address to, uint256 amount) public returns (bool) {
// If `amount` is 0, or `msg.sender` is `to` nothing happens
if (amount != 0 || msg.sender == to) {
uint256 srcBalance = balanceOf[msg.sender];
require(srcBalance >= amount, "ERC20: balance too low");
if (msg.sender != to) {
require(to != address(0), "ERC20: no zero address"); // Moved down so low balance calls safe some gas
balanceOf[msg.sender] = srcBalance - amount; // Underflow is checked
balanceOf[to] += amount;
}
}
emit Transfer(msg.sender, to, amount);
return true;
}
/// @notice Transfers `amount` tokens from `from` to `to`. Caller needs approval for `from`.
/// @param from Address to draw tokens from.
/// @param to The address to move the tokens.
/// @param amount The token amount to move.
/// @return (bool) Returns True if succeeded.
function transferFrom(address from,
address to,
uint256 amount) public returns (bool) {
// If `amount` is 0, or `from` is `to` nothing happens
if (amount != 0) {
uint256 srcBalance = balanceOf[from];
require(srcBalance >= amount, "ERC20: balance too low");
if (from != to) {
uint256 spenderAllowance = allowance[from][msg.sender];
// If allowance is infinite, don't decrease it to save on gas (breaks with EIP-20).
if (spenderAllowance != type(uint256).max) {
require(spenderAllowance >= amount, "ERC20: allowance too low");
allowance[from][msg.sender] = spenderAllowance - amount; // Underflow is checked
}
require(to != address(0), "ERC20: no zero address"); // Moved down so other failed calls safe some gas
balanceOf[from] = srcBalance - amount; // Underflow is checked
balanceOf[to] += amount;
}
}
emit Transfer(from, to, amount);
return true;
}
/// @notice Approves `amount` from sender to be spend by `spender`.
/// @param spender Address of the party that can draw from msg.sender's account.
/// @param amount The maximum collective amount that `spender` can draw.
/// @return (bool) Returns True if approved.
function approve(address spender, uint256 amount) public override returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return _domainSeparator();
}
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private constant PERMIT_SIGNATURE_HASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/// @notice Approves `value` from `owner_` to be spend by `spender`.
/// @param owner_ Address of the owner.
/// @param spender The address of the spender that gets approved to draw from `owner_`.
/// @param value The maximum collective amount that `spender` can draw.
/// @param deadline This permit must be redeemed before this deadline (UTC timestamp in seconds).
function permit(address owner_,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external override {
require(owner_ != address(0), "ERC20: Owner cannot be 0");
require(block.timestamp < deadline, "ERC20: Expired");
require(ecrecover(_getDigest(keccak256(abi.encode(PERMIT_SIGNATURE_HASH, owner_, spender, value, nonces[owner_]++, deadline))), v, r, s) ==
owner_,
"ERC20: Invalid Signature");
allowance[owner_][spender] = value;
emit Approval(owner_, spender, value);
}
}
// Contract: BoringMath
/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
}
}
/// @title Spell
/// @author 0xMerlin
/// @dev This contract spreads Magic.
contract Spell is ERC20, BoringOwnable {
using BoringMath for uint256;
// ERC20 'variables'
string public constant symbol = "SPELL";
string public constant name = "Spell Token";
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public constant MAX_SUPPLY = 420 * 1e27;
function mint(address to, uint256 amount) public onlyOwner {
require(to != address(0), "SPELL: no mint to zero address");
require(MAX_SUPPLY >= totalSupply.add(amount), "SPELL: Don't go over MAX");
totalSupply = totalSupply + amount;
balanceOf[to] += amount;
emit Transfer(address(0), to, amount);
}
}
| 231,403 | 11 |
b873d53c001850bf49e8f2ce00e9ccaab714af737656ee2a67e4ad3c2c36b605
| 30,552 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xbf29F08404C3efa8CcF679c51eFA0b65F1fCFa78/contract.sol
| 3,914 | 15,282 |
// 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;
// ZulaToken with Governance.
contract ZulaToken is BEP20('ZulaToken', 'ZULA') {
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), "ZULA::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "ZULA::delegateBySig: invalid nonce");
require(now <= expiry, "ZULA::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, "ZULA::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 ZULAs (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, "ZULA::_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;
}
}
| 257,692 | 12 |
163911596c83f7e569325c37532b2c2a17555e734f6731fee41ecd61551951bd
| 21,065 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xe7750c38c9a10d877650c0d99d1717bb28a5c42e.sol
| 3,050 | 11,575 |
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
// ERC20 ------------------------------------------------------------------------------
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;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
contract 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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_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 _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
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 ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super._mint(account, value);
}
}
//-------------------------------------------------------------------------------------
contract ZikToken is ERC20Capped, ERC20Detailed {
constructor() public
ERC20Detailed("Ziktalk Token", "ZIK", 18)
ERC20Capped(1e28)
{
}
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
| 214,887 | 13 |
95773784166e93c749408ba47a3b356093212a6c5d92ce2c34d09a4f4317f083
| 14,804 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8e/8E347e33d991a51F5b654245C054Bc5A6BC60cE1_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 326,718 | 14 |
67b2a6a3f4218c063c1449071ba8c802b42dc6bdb2ff99a2e976440f30e43023
| 17,357 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/uninitializedLocalVariables/0xa387d2be9f737612fa85c86d0234e36e3f2a048b_uninitializedLocalStateVariables.sol
| 3,289 | 12,982 |
pragma solidity 0.6.11;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
// 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 ; //inject UNINIT LOCAL/STATE VAR
assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex ; //inject UNINIT LOCAL/STATE VAR
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex ; //inject UNINIT LOCAL/STATE VAR
uint256 lastIndex ; //inject UNINIT LOCAL/STATE VAR
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue ; //inject UNINIT LOCAL/STATE VAR
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract VaultTimely is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// trusted deposit token contract address
address public constant trustedDepositTokenAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
// trusted reward token contract address
address public constant trustedRewardTokenAddress = 0xf4CD3d3Fda8d7Fd6C5a500203e38640A70Bf9577;
// reward rate
uint public rewardRatePercentX100 ; //inject UNINIT LOCAL/STATE VAR
uint public constant rewardInterval = 365 days;
uint public cliffTime ; //inject UNINIT LOCAL/STATE VAR
uint public withdrawFeePercentX100 ; //inject UNINIT LOCAL/STATE VAR
uint public totalClaimedRewards ; //inject UNINIT LOCAL/STATE VAR
uint public vaultDuration ; //inject UNINIT LOCAL/STATE VAR
// admin can transfer out reward tokens from this contract one month after vault has ended
uint public adminCanClaimAfter ; //inject UNINIT LOCAL/STATE VAR
uint public vaultDeployTime;
uint public adminClaimableTime;
uint public vaultEndTime;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
constructor () public {
vaultDeployTime = now;
vaultEndTime = vaultDeployTime.add(vaultDuration);
adminClaimableTime = vaultDeployTime.add(adminCanClaimAfter);
}
function updateAccount(address account) private {
uint pendingDivs ; //inject UNINIT LOCAL/STATE VAR
if (pendingDivs > 0) {
require(Token(trustedRewardTokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = now;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff;
uint _now ; //inject UNINIT LOCAL/STATE VAR
if (_now > vaultEndTime) {
_now = vaultEndTime;
}
if (lastClaimedTime[_holder] >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastClaimedTime[_holder]);
}
uint depositedAmount ; //inject UNINIT LOCAL/STATE VAR
uint pendingDivs ; //inject UNINIT LOCAL/STATE VAR
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToDeposit) public {
require(amountToDeposit > 0, "Cannot deposit 0 Tokens");
require(Token(trustedDepositTokenAddress).transferFrom(msg.sender, address(this), amountToDeposit), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToDeposit);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
depositTime[msg.sender] = now;
}
}
function withdraw(uint amountToWithdraw) public {
require(amountToWithdraw > 0, "Cannot withdraw 0 Tokens");
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
updateAccount(msg.sender);
uint fee ; //inject UNINIT LOCAL/STATE VAR
uint amountAfterFee ; //inject UNINIT LOCAL/STATE VAR
require(Token(trustedDepositTokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(trustedDepositTokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
// emergency withdraw without caring about pending earnings
// pending earnings will be lost / set to 0 if used emergency withdraw
function emergencyWithdraw(uint amountToWithdraw) public {
require(amountToWithdraw > 0, "Cannot withdraw 0 Tokens");
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
// set pending earnings to 0 here
lastClaimedTime[msg.sender] = now;
uint fee ; //inject UNINIT LOCAL/STATE VAR
uint amountAfterFee ; //inject UNINIT LOCAL/STATE VAR
require(Token(trustedDepositTokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(trustedDepositTokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claim() public {
updateAccount(msg.sender);
}
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length ; //inject UNINIT LOCAL/STATE VAR
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i ; i < endIndex; i = i.add(1)) { //inject UNINIT LOCAL/STATE VAR
address staker ; //inject UNINIT LOCAL/STATE VAR
uint listIndex ; //inject UNINIT LOCAL/STATE VAR
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
// function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
// Admin cannot transfer out deposit tokens from this smart contract
// Admin can transfer out reward tokens from this address once adminClaimableTime has reached
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require(_tokenAddr != trustedDepositTokenAddress, "Admin cannot transfer out Deposit Tokens from this contract!");
require((_tokenAddr != trustedRewardTokenAddress) || (now > adminClaimableTime), "Admin cannot Transfer out Reward Tokens yet!");
Token(_tokenAddr).transfer(_to, _amount);
}
}
| 279,498 | 15 |
554a787055637bd67384a8596470540f41081b2199a0417c7c0e2078a63fabea
| 27,719 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/18/18034885bccfd8fa932772b3c3b6d5542257e766_Reservoir.sol
| 5,457 | 21,006 |
pragma solidity ^0.4.25;
interface IToken {
function approve(address spender, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
interface ISwap {
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) external view returns (uint256);
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) external view returns (uint256);
function bnbToTokenSwapInput(uint256 min_tokens) external payable returns (uint256);
function bnbToTokenSwapOutput(uint256 tokens_bought) external payable returns (uint256);
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) external returns (uint256);
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) external returns (uint256);
function getBnbToTokenInputPrice(uint256 bnb_sold) external view returns (uint256);
function getBnbToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256);
function getTokenToBnbInputPrice(uint256 tokens_sold) external view returns (uint256);
function getTokenToBnbOutputPrice(uint256 bnb_bought) external view returns (uint256) ;
function tokenAddress() external view returns (address) ;
function bnbBalance() external view returns (uint256);
function tokenBalance() external view returns (uint256);
function getBnbToLiquidityInputPrice(uint256 bnb_sold) external view returns (uint256);
function getLiquidityToReserveInputPrice(uint amount) external view returns (uint256, uint256);
function txs(address owner) external view returns (uint256) ;
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) external payable returns (uint256) ;
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) external returns (uint256, uint256);
}
contract Reservoir {
using SafeMath for uint;
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends() > 0);
_;
}
event onLeaderBoard(address indexed customerAddress,
uint256 invested,
uint256 tokens,
uint256 soldTokens,
uint256 timestamp);
event onTokenPurchase(address indexed customerAddress,
uint256 incomingeth,
uint256 tokensMinted,
uint timestamp);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethEarned,
uint timestamp);
event onReinvestment(address indexed customerAddress,
uint256 ethReinvested,
uint256 tokensMinted,
uint256 timestamp);
event onWithdraw(address indexed customerAddress,
uint256 ethWithdrawn,
uint256 timestamp);
event onClaim(address indexed customerAddress,
uint256 tokens,
uint256 timestamp);
event onTransfer(address indexed from,
address indexed to,
uint256 tokens,
uint256 timestamp);
event onBalance(uint256 bnbBalance,
uint256 tokenBalance,
uint256 timestamp);
event onLiquiditySweep(uint amount);
event onLiquidityProviderReward(uint amount);
// Onchain Stats!!!
struct Stats {
uint invested;
uint reinvested;
uint withdrawn;
uint rewarded;
uint taxes;
uint contributed;
uint transferredTokens;
uint receivedTokens;
uint xInvested;
uint xReinvested;
uint xRewarded;
uint xContributed;
uint xWithdrawn;
uint xTransferredTokens;
uint xReceivedTokens;
}
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 10;
uint8 constant internal exitFee_ = 10;
uint8 constant internal dripFee = 50;
uint8 constant internal instantFee = 20;
uint8 constant payoutRate_ = 2;
uint256 constant internal magnitude = 2 ** 64;
uint constant MAX_UINT = 2**256 - 1;
// amount of shares for each address (scaled number)
mapping(address => uint256) private tokenBalanceLedger_;
mapping(address => int256) private payoutsTo_;
mapping(address => Stats) private stats;
//on chain referral tracking
uint256 private tokenSupply_;
uint256 private profitPerShare_;
uint256 public totalDeposits;
uint256 public totalWithdrawn;
uint256 internal lastBalance_;
uint private lockedBalance;
uint public players;
uint public totalTxs;
uint public dividendBalance;
uint public lastPayout;
uint public totalClaims;
uint256 public balanceInterval = 30 seconds;
uint256 public distributionInterval = 3 seconds;
address public swapAddress;
address public collateralAddress;
IToken private swapToken;
IToken private cToken;
ISwap private swap;
constructor(address _swapAddress, address _collateralAddress) public {
swapAddress = _swapAddress;
collateralAddress = _collateralAddress;
swapToken = IToken(_swapAddress);
swap = ISwap(_swapAddress);
cToken = IToken(_collateralAddress);
lastPayout = now;
}
/// @dev converts BNB into liquidity and buys
function buy() public payable returns (uint256){
require(msg.value >= 1e16, "min buy is 0.01 BNB");
totalDeposits += msg.value;
//Refresh approvals
approveSwap();
//use dust from previous txs
uint balance = address(this).balance;
uint tokens = sellBnb(balance / 2);
//the secret sauce for adding liquidity properly
uint bnbAmount = SafeMath.min(swap.getTokenToBnbInputPrice(tokens), address(this).balance);
//If you don't get bnbAmount from the contract you will have pain
uint liquidAmount = swap.addLiquidity.value(bnbAmount)(1, tokens);
return buyFor(msg.sender, liquidAmount);
}
function buyFor(address _customerAddress, uint _buy_amount) internal returns (uint256) {
uint amount = purchaseTokens(_customerAddress, _buy_amount);
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return amount;
}
function() public payable {
//DO NOTHING!!! Swap will send BNB to us!!!
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() public onlyStronghands returns (uint) {
// fetch dividends
uint256 _dividends = myDividends();
// retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(msg.sender, _dividends);
uint bnbAmount = calculateLiquidityToBnb(_dividends);
// fire event
emit onReinvestment(_customerAddress, bnbAmount, _tokens, now);
//Stats
stats[_customerAddress].reinvested = SafeMath.add(stats[_customerAddress].reinvested, bnbAmount);
stats[_customerAddress].xReinvested += 1;
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return _tokens;
}
/// @dev Withdraws all of the callers earnings.
function withdraw() public onlyStronghands returns (uint) {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(); // 100% of divs
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
//remove liquidity and sell the tokens for BNB
(uint bnbAmount, uint tokenAmount) = swap.removeLiquidity(_dividends,1,1);
bnbAmount = bnbAmount.add(sellTokens(tokenAmount));
// lambo delivery service
_customerAddress.transfer(bnbAmount);
totalWithdrawn += bnbAmount;
//stats
stats[_customerAddress].withdrawn = SafeMath.add(stats[_customerAddress].withdrawn, bnbAmount);
stats[_customerAddress].xWithdrawn += 1;
totalTxs += 1;
totalClaims += _dividends;
// fire event
emit onWithdraw(_customerAddress, bnbAmount, now);
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return bnbAmount;
}
function sell(uint256 _amountOfTokens) onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// data setup
uint256 _undividedDividends = SafeMath.mul(_amountOfTokens, exitFee_) / 100;
uint256 _taxedeth = SafeMath.sub(_amountOfTokens, _undividedDividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _amountOfTokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens + (_taxedeth * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
//drip and buybacks
allocateFees(_undividedDividends);
// fire event
emit onTokenSell(_customerAddress, _amountOfTokens, _taxedeth, now);
//distribute
distribute();
}
function totalTokenBalance() public view returns (uint256) {
return swapToken.balanceOf(address(this));
}
function lockedTokenBalance() public view returns (uint256) {
return lockedBalance;
}
function collateralBalance() public view returns (uint256) {
return cToken.balanceOf(address(this));
}
/// @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() public view returns (uint256) {
address _customerAddress = msg.sender;
return 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 token balance of any single address.
function bnbBalance(address _customerAddress) public view returns (uint256) {
return _customerAddress.balance;
}
/// @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;
}
function approveSwap() internal {
require(cToken.approve(swapAddress, MAX_UINT), "Need to approve swap before selling tokens");
}
function sellTokens(uint256 amount) internal returns (uint256) {
approveSwap();
return swap.tokenToBnbSwapInput(amount,1);
}
function sellBnb(uint256 amount) internal returns (uint256){
return swap.bnbToTokenSwapInput.value(amount)(1);
}
function calculateLiquidityToBnb(uint256 _amount) public view returns (uint256) {
if (_amount > 0){
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(_amount);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
function calculateTaxedBnbToTokenLiquidity(uint256 _amount) public view returns (uint256) {
if (_amount > 0){
uint amount = swap.getBnbToLiquidityInputPrice(_amount.div(2));
return amount.mul(SafeMath.sub(100,entryFee_)).div(100);
} else {
return 0;
}
}
function calculateTaxedLiquidityToBnb(uint256 _amount) public view returns (uint256){
if (_amount > 0){
_amount = _amount.mul(SafeMath.sub(100,entryFee_)).div(100);
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(_amount);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
function sweep() public returns (uint256){
uint balanceOriginTokens = collateralBalance();
if (balanceOriginTokens >= 1e18 && tokenSupply_ > 0){
uint halfTokens = balanceOriginTokens.div(2);
uint balanceBnb = sellTokens(halfTokens);
uint balanceTokens = collateralBalance();
//the secret sauce for adding liquidity properly
uint bnbAmount = SafeMath.min(swap.getTokenToBnbInputPrice(balanceTokens), balanceBnb);
//If you don't get bnbAmount from the contract you will have pain
uint liquidAmount = swap.addLiquidity.value(bnbAmount)(1, balanceTokens);
//half goes to lock and the other half goes to Stronghold LPs
uint halfLiq = liquidAmount.div(2);
uint sweepBalance = liquidAmount.sub(halfLiq);
//Add the new liquidity to drip dividends;
dividendBalance += sweepBalance;
//Add the new liquidity to locked; Stronghold should show up on the leaderboard
lockedBalance += halfLiq;
emit onLiquiditySweep(halfLiq);
emit onLiquidityProviderReward(halfLiq);
return liquidAmount;
} else {
return 0;
}
}
/// @dev Stats of any single address
function statsOf(address _customerAddress) public view returns (uint256[15] memory){
Stats memory s = stats[_customerAddress];
uint256[15] memory statArray = [s.invested, s.withdrawn, s.rewarded, s.taxes, s.contributed, s.transferredTokens, s.receivedTokens, s.xInvested, s.xRewarded, s.xContributed, s.xWithdrawn, s.xTransferredTokens, s.xReceivedTokens, s.reinvested, s.xReinvested];
return statArray;
}
/// @dev Calculate daily estimate of swap tokens awarded in BNB
function dailyEstimateBnb(address _customerAddress) public view returns (uint256){
if (tokenSupply_ > 0){
uint256 share = dividendBalance.mul(payoutRate_).div(100);
uint256 estimate = share.mul(tokenBalanceLedger_[_customerAddress]).div(tokenSupply_);
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(estimate);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
/// @dev Calculate daily estimate of swap tokens awarded
function dailyEstimate(address _customerAddress) public view returns (uint256){
uint256 share = dividendBalance.mul(payoutRate_).div(100);
return (tokenSupply_ > 0) ? share.mul(tokenBalanceLedger_[_customerAddress]).div(tokenSupply_) : 0;
}
/// @dev Distribute undividend in and out fees across drip pools and instant divs
function allocateFees(uint fee) private {
uint _share = fee.div(100);
uint _drip = _share.mul(dripFee); //40 --> 50
uint _instant = _share.mul(instantFee); //40 --> 20
uint _lock = fee.safeSub(_drip + _instant); //20 --> 30
if (tokenSupply_ > 0) {
//Apply divs
profitPerShare_ = SafeMath.add(profitPerShare_, (_instant * magnitude) / tokenSupply_);
}
//Add to dividend drip pools
dividendBalance += _drip;
//Add locked tokens to global count;
lockedBalance += _lock;
}
// @dev Distribute drip pools
function distribute() private {
// @Bb updates balance data of contract
if (now.safeSub(lastBalance_) > balanceInterval && totalTokenBalance() > 0) {
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(totalTokenBalance());
emit onBalance(bnbAmount, tokenAmount, now);
lastBalance_ = now;
}
if (SafeMath.safeSub(now, lastPayout) > distributionInterval && tokenSupply_ > 0) {
//A portion of the dividend is paid out according to the rate
uint256 share = dividendBalance.mul(payoutRate_).div(100).div(24 hours);
//divide the profit by seconds in the day
uint256 profit = share * now.safeSub(lastPayout);
//share times the amount of time elapsed
dividendBalance = dividendBalance.safeSub(profit);
//Apply divs
profitPerShare_ = SafeMath.add(profitPerShare_, (profit * magnitude) / tokenSupply_);
sweep();
lastPayout = now;
}
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(address _customerAddress, uint256 _incomingtokens) internal returns (uint256) {
if (stats[_customerAddress].invested == 0 && stats[_customerAddress].receivedTokens == 0) {
players += 1;
}
totalTxs += 1;
// data setup @bb _incomingtokens is 'LP token'
uint256 _undividedDividends = SafeMath.mul(_incomingtokens, entryFee_) / 100; // 10% of drops
uint256 _amountOfTokens = SafeMath.sub(_incomingtokens, _undividedDividends); // 90% of drops (100% - 10% above)
uint256 bnbAmount = calculateLiquidityToBnb(_incomingtokens); //total bnb worth of lp token
// fire event
emit onTokenPurchase(_customerAddress, bnbAmount, _amountOfTokens, now);
// yes we know that the safemath function automatically rules out the "greater then" equation.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_, "Tokens need to be positive");
// we can't give people infinite eth
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ += _amountOfTokens;
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
//drip and buybacks; instant requires being called after supply is updated
allocateFees(_undividedDividends);
// 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;
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_customerAddress] += _updatedPayouts;
//Stats
stats[_customerAddress].taxes += _undividedDividends;
stats[_customerAddress].invested += bnbAmount;
stats[_customerAddress].xInvested += 1;
return _amountOfTokens;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
| 113,875 | 16 |
0004ba6547a87ae5a079925c89b3ea59e513826369ef1d25fafa7966fe8d4185
| 27,653 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x621A1c70df7D91830308bf8cCE23829218E563b9/contract.sol
| 3,850 | 15,169 |
pragma solidity >=0.6.4;
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;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
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');
_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'));
}
}
contract TRPCToken is BEP20('Tropico Finance TRPC', 'TRPC') {
/// @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), "TRPC::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "TRPC::delegateBySig: invalid nonce");
require(now <= expiry, "TRPC::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, "TRPC::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 TRPCs (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, "TRPC::_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;
}
}
| 251,866 | 17 |
ec8e7a937e2650decf98445c126b348f99f7d6a4f7b524d3ec9064b181b0bd4b
| 15,397 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xd6bdf5d0aa3de762d0dd65bcc5c143687ee6e192.sol
| 3,533 | 13,968 |
pragma solidity ^0.4.20;
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223 {
function balanceOf(address who) public view returns (uint);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed burner, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract EEYcoin is ERC223 {
using SafeMath for uint256;
using SafeMath for uint;
address public owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
mapping (address => uint) public increase;
mapping (address => uint256) public unlockUnixTime;
uint public maxIncrease=20;
address public target;
string internal name_= "EEYcoin";
string internal symbol_ = "EEY";
uint8 internal decimals_= 18;
uint256 internal totalSupply_= 100000000e18;
uint256 public toGiveBase = 3e18;
uint256 public increaseBase = 100e18;
uint256 public OfficalHold = totalSupply_.mul(18).div(100);
uint256 public totalRemaining = totalSupply_;
uint256 public totalDistributed = 0;
bool public canTransfer = true;
uint256 public etherGetBase=20000;
bool public distributionFinished = false;
bool public finishFreeGetToken = false;
bool public finishEthGetToken = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier canTrans() {
require(canTransfer == true);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function EEYcoin (address _target) public {
owner = msg.sender;
target = _target;
distr(target, OfficalHold);
}
// Function to access name of token .
function name() public view returns (string _name) {
return name_;
}
// Function to access symbol of token .
function symbol() public view returns (string _symbol) {
return symbol_;
}
// Function to access decimals of token .
function decimals() public view returns (uint8 _decimals) {
return decimals_;
}
// Function to access total supply of tokens .
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply_;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) canTrans public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) canTrans public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) canTrans public returns (bool success) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function changeOwner(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function changeIncrease(address[] addresses, uint256[] _amount) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
require(_amount[i] <= maxIncrease);
increase[addresses[i]] = _amount[i];
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
return true;
}
function startDistribution() onlyOwner public returns (bool) {
distributionFinished = false;
return true;
}
function finishFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = true;
return true;
}
function finishEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = true;
return true;
}
function startFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = false;
return true;
}
function startEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = false;
return true;
}
function startTransfer() onlyOwner public returns (bool) {
canTransfer = true;
return true;
}
function stopTransfer() onlyOwner public returns (bool) {
canTransfer = false;
return true;
}
function changeBaseValue(uint256 _toGiveBase,uint256 _increaseBase,uint256 _etherGetBase,uint _maxIncrease) onlyOwner public returns (bool) {
toGiveBase = _toGiveBase;
increaseBase = _increaseBase;
etherGetBase=_etherGetBase;
maxIncrease=_maxIncrease;
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
require(totalRemaining >= 0);
require(_amount<=totalRemaining);
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(address(0), _to, _amount);
return true;
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint8 i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (toGiveBase > totalRemaining) {
toGiveBase = totalRemaining;
}
address investor = msg.sender;
uint256 etherValue=msg.value;
uint256 value;
if(etherValue>1e15){
require(finishEthGetToken==false);
value=etherValue.mul(etherGetBase);
value=value.add(toGiveBase);
require(value <= totalRemaining);
distr(investor, value);
if(!owner.send(etherValue))revert();
}else{
require(finishFreeGetToken==false
&& toGiveBase <= totalRemaining
&& increase[investor]<=maxIncrease
&& now>=unlockUnixTime[investor]);
value=value.add(increase[investor].mul(increaseBase));
value=value.add(toGiveBase);
increase[investor]+=1;
distr(investor, value);
unlockUnixTime[investor]=now+1 days;
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function transferFrom(address _from, address _to, uint256 _value) canTrans public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& blacklist[_from] == false
&& blacklist[_to] == false);
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 success) {
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 getTokenBalance(address tokenAddress, address who) constant public returns (uint256){
ForeignToken t = ForeignToken(tokenAddress);
uint256 bal = t.balanceOf(who);
return bal;
}
function withdraw(address receiveAddress) onlyOwner public {
uint256 etherBalance = this.balance;
if(!receiveAddress.send(etherBalance))revert();
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
totalDistributed = totalDistributed.sub(_value);
Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 141,675 | 18 |
9dfe98849ad2a2127b64c787c36dc4dd6e12bd74f053baab3334a4ecfaac0653
| 20,798 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb2a2a66d2a813ac32b940c406f14a06b390d442a.sol
| 3,079 | 11,765 |
pragma solidity ^0.4.24;
// File: contracts/ownership/MultiOwnable.sol
contract MultiOwnable {
address public manager; // address used to set owners
address[] public owners;
mapping(address => bool) public ownerByAddress;
event SetOwners(address[] owners);
modifier onlyOwner() {
require(ownerByAddress[msg.sender] == true);
_;
}
function MultiOwnable() public {
manager = msg.sender;
}
function setOwners(address[] _owners) public {
require(msg.sender == manager);
_setOwners(_owners);
}
function _setOwners(address[] _owners) internal {
for(uint256 i = 0; i < owners.length; i++) {
ownerByAddress[owners[i]] = false;
}
for(uint256 j = 0; j < _owners.length; j++) {
ownerByAddress[_owners[j]] = true;
}
owners = _owners;
emit SetOwners(_owners);
}
function getOwners() public constant returns (address[]) {
return owners;
}
}
// File: contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/token/ERC20/ERC20.sol
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 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) {
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 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)
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 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: contracts/token/ITokenEventListener.sol
interface ITokenEventListener {
function onTokenTransfer(address _from, address _to, uint256 _value) external;
}
// File: contracts/token/ManagedToken.sol
contract ManagedToken is StandardToken, MultiOwnable {
bool public allowTransfers = false;
bool public issuanceFinished = false;
ITokenEventListener public eventListener;
event AllowTransfersChanged(bool _newState);
event Issue(address indexed _to, uint256 _value);
event Destroy(address indexed _from, uint256 _value);
event IssuanceFinished();
modifier transfersAllowed() {
assert(allowTransfers);
_;
}
modifier canIssue() {
assert(!issuanceFinished);
_;
}
function ManagedToken(address _listener, address[] _owners) public {
if(_listener != address(0)) {
eventListener = ITokenEventListener(_listener);
}
_setOwners(_owners);
}
function setAllowTransfers(bool _allowTransfers) external onlyOwner {
allowTransfers = _allowTransfers;
emit AllowTransfersChanged(_allowTransfers);
}
function setListener(address _listener) public onlyOwner {
if(_listener != address(0)) {
eventListener = ITokenEventListener(_listener);
} else {
delete eventListener;
}
}
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool) {
bool success = super.transfer(_to, _value);
if(hasListener() && success) {
eventListener.onTokenTransfer(msg.sender, _to, _value);
}
return success;
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if(hasListener() && success) {
eventListener.onTokenTransfer(_from, _to, _value);
}
return success;
}
function hasListener() internal view returns(bool) {
if(eventListener == address(0)) {
return false;
}
return true;
}
function issue(address _to, uint256 _value) external onlyOwner canIssue {
}
function destroy(address _from, uint256 _value) external {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = SafeMath.add(allowed[msg.sender][_spender], _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] = SafeMath.sub(oldValue, _subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function finishIssuance() public onlyOwner {
issuanceFinished = true;
emit IssuanceFinished();
}
}
// File: contracts/token/TransferLimitedToken.sol
contract TransferLimitedToken is ManagedToken {
mapping(address => bool) public limitedWallets;
address public limitedWalletsManager;
bool public isLimitEnabled;
modifier onlyManager() {
require(msg.sender == limitedWalletsManager);
_;
}
modifier canTransfer(address _from, address _to) {
require(!isLimitEnabled || (!limitedWallets[_from] && !limitedWallets[_to]));
_;
}
function TransferLimitedToken(address _listener, address[] _owners, address _limitedWalletsManager) public
ManagedToken(_listener, _owners)
{
isLimitEnabled = true;
limitedWalletsManager = _limitedWalletsManager;
}
function addLimitedWalletAddress(address _wallet) public onlyManager {
limitedWallets[_wallet] = true;
}
function delLimitedWalletAddress(address _wallet) public onlyManager {
limitedWallets[_wallet] = false;
}
function isLimitedWalletAddress(address _wallet) public view returns(bool) {
return limitedWallets[_wallet];
}
function setLimitEnabled(bool _setLimitEnabled) public onlyManager {
isLimitEnabled = _setLimitEnabled;
}
function transfer(address _to, uint256 _value) public canTransfer(msg.sender, _to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from, _to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public canTransfer(msg.sender, _spender) returns (bool) {
return super.approve(_spender,_value);
}
}
// File: contracts/MCCToken.sol
contract MCCToken is TransferLimitedToken {
// Members
string public name = "MyCreditChain";
string public symbol = "MCC";
uint8 public decimals = 18;
event Burn(address indexed burner, uint256 value);
// Constructor
function MCCToken(address _listener, address[] _owners, address _manager) public
TransferLimitedToken(_listener, _owners, _manager)
{
totalSupply_ = uint256(1000000000).mul(uint256(10) ** decimals); // token total supply : 1000000000
balances[_owners[0]] = totalSupply_;
}
function issue(address _to, uint256 _value) external onlyOwner canIssue {
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Issue(_to, _value);
emit Transfer(msg.sender, _to, _value);
}
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
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);
}
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);
}
}
| 193,205 | 19 |
b59ee6b33d2b80f8bc6e8ed2b10ef5b0bbb29b2da8586146aa537af47d17d28c
| 18,266 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/89/89f092342b20012ccab7936ada7d9d5df8df4cc2_Minter.sol
| 4,273 | 14,905 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function mint(address account_, uint256 amount_) external;
function decimals() external view returns (uint8);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
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() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Minter is Ownable {
using SafeMath for uint256;
address public Waceo;
address public Stable;
address public Wavax;
address public WAVAX_WACEO_LP;
address public WAVAX_STABLE_LP;
struct Distribution {
address _address;
uint256 _amount;
}
struct DAO{
uint256 _amount;
address _token;
address _lp;
address _address;
}
struct BasicRequest {
address Recipient;
uint256 Amount;
uint256 Timestamp;
bool Approved;
bool Active;
}
struct SingleAutoAllocationRequest {
uint256 Amount;
Distribution LP_Controller;
Distribution Founding_Team;
Distribution WACEO_LP_Rewards;
Distribution WACEO_Operational;
Distribution WACEO_Dev;
Distribution WACEO_Regulations;
Distribution WACEO_Unrekt;
uint256 Timestamp;
bool Approved;
bool Active;
}
struct DoubleAutoAllocationRequest {
DAO Dao;
Distribution LP_Controller;
Distribution Founding_Team;
Distribution WACEO_LP_Rewards;
Distribution WACEO_Operational;
Distribution WACEO_Dev;
Distribution WACEO_Regulations;
Distribution WACEO_Unrekt;
uint256 Timestamp;
bool Approved;
bool Active;
}
mapping(address => BasicRequest) public basic_mintRequests;
mapping(address => SingleAutoAllocationRequest) public single_autoAllocation_mintRequests;
mapping(address => DoubleAutoAllocationRequest) public double_autoAllocation_mintRequests;
constructor(address _waceo,
address _stable,
address _wavax,
address _wavax_waceo_lp,
address _wavax_stable_lp) Ownable() {
Waceo = _waceo;
Stable = _stable;
Wavax = _wavax;
WAVAX_WACEO_LP = _wavax_waceo_lp;
WAVAX_STABLE_LP = _wavax_stable_lp;
}
function validateDistribution(Distribution memory _distribution) internal pure returns(bool){
if(_distribution._amount > 0 && _distribution._address != address(0)){
return true;
}else {
return false;
}
}
function validateDAO(DAO memory _dao) internal pure returns(bool){
if(_dao._amount > 0 &&
_dao._address != address(0) &&
_dao._lp != address(0) &&
_dao._token != address(0)){
return true;
}else {
return false;
}
}
function _mint_basic (address _address,
uint256 _amount) external returns (bool){
require(_amount > 0, "BASIC_MINT_REQUEST: Wrong amount");
require(_address != address(0), "BASIC_MINT_REQUEST: Wrong address");
basic_mintRequests[msg.sender] = BasicRequest({
Recipient: _address,
Amount: _amount,
Timestamp: block.timestamp,
Approved: false,
Active: true
});
return true;
}
function _mint_auto_allocate_single (uint256 _amount,
Distribution memory _lp_controller,
Distribution memory _founding_team,
Distribution memory _waceo_lp_rewards,
Distribution memory _waceo_operational,
Distribution memory _waceo_dev,
Distribution memory _waceo_regulations,
Distribution memory _waceo_unrekt) external returns (bool){
require(_amount > 0, "Wrong amount");
require(validateDistribution(_lp_controller), "LP_Controller: Wrong values");
require(validateDistribution(_founding_team), "Founding_Team: Wrong values");
require(validateDistribution(_waceo_lp_rewards), "Waceo_LP_Rewards: Wrong values");
require(validateDistribution(_waceo_operational), "Waceo_Operational: Wrong values");
require(validateDistribution(_waceo_dev), "Waceo_Dev: Wrong values");
require(validateDistribution(_waceo_regulations), "Waceo_Regulations: Wrong values");
require(validateDistribution(_waceo_unrekt), "Waceo_Unrekt: Wrong values");
single_autoAllocation_mintRequests[msg.sender] = SingleAutoAllocationRequest({
Amount: _amount,
LP_Controller: _lp_controller,
Founding_Team: _founding_team,
WACEO_LP_Rewards: _waceo_lp_rewards,
WACEO_Operational: _waceo_operational,
WACEO_Dev: _waceo_dev,
WACEO_Regulations: _waceo_regulations,
WACEO_Unrekt: _waceo_unrekt,
Timestamp: block.timestamp,
Approved: false,
Active: true
});
return true;
}
function _mint_auto_allocate_double (DAO memory _dao,
Distribution memory _lp_controller,
Distribution memory _founding_team,
Distribution memory _waceo_lp_rewards,
Distribution memory _waceo_operational,
Distribution memory _waceo_dev,
Distribution memory _waceo_regulations,
Distribution memory _waceo_unrekt) external returns (bool){
require(validateDAO(_dao), "DAO: Wrong values");
require(validateDistribution(_lp_controller), "LP_Controller: Wrong values");
require(validateDistribution(_founding_team), "Founding_Team: Wrong values");
require(validateDistribution(_waceo_lp_rewards), "Waceo_LP_Rewards: Wrong values");
require(validateDistribution(_waceo_operational), "Waceo_Operational: Wrong values");
require(validateDistribution(_waceo_dev), "Waceo_Dev: Wrong values");
require(validateDistribution(_waceo_regulations), "Waceo_Regulations: Wrong values");
require(validateDistribution(_waceo_unrekt), "Waceo_Unrekt: Wrong values");
double_autoAllocation_mintRequests[msg.sender] = DoubleAutoAllocationRequest({
Dao: _dao,
LP_Controller: _lp_controller,
Founding_Team: _founding_team,
WACEO_LP_Rewards: _waceo_lp_rewards,
WACEO_Operational: _waceo_operational,
WACEO_Dev: _waceo_dev,
WACEO_Regulations: _waceo_regulations,
WACEO_Unrekt: _waceo_unrekt,
Timestamp: block.timestamp,
Approved: false,
Active: true
});
return true;
}
function approve_basic_mint(address _address) external onlyOwner returns(bool){
require(basic_mintRequests[_address].Active, "There are no requests from the _address");
require(basic_mintRequests[_address].Approved == false, "The request already approved");
BasicRequest storage request = basic_mintRequests[_address];
IERC20(Waceo).mint(request.Recipient, request.Amount);
request.Approved = true;
return true;
}
function approve_auto_allocate_single(address _address) external onlyOwner returns(bool){
require(single_autoAllocation_mintRequests[_address].Active, "There are no requests from the _address");
require(single_autoAllocation_mintRequests[_address].Approved == false, "The request already approved");
SingleAutoAllocationRequest storage request = single_autoAllocation_mintRequests[_address];
uint256 _LP_Controller_Value = request.Amount.mul(request.LP_Controller._amount.div(10**IERC20(Waceo).decimals())).div(100);
uint256 _Founding_Team_Value = request.Amount.mul(request.Founding_Team._amount.div(10**IERC20(Waceo).decimals())).div(100);
uint256 _WACEO_LP_Rewards_Value = request.Amount.mul(request.WACEO_LP_Rewards._amount.div(10**IERC20(Waceo).decimals())).div(100);
uint256 _WACEO_Operational_Value = request.Amount.mul(request.WACEO_Operational._amount.div(10**IERC20(Waceo).decimals())).div(100);
uint256 _WACEO_Dev_Value = request.Amount.mul(request.WACEO_Dev._amount.div(10**IERC20(Waceo).decimals())).div(100);
uint256 _WACEO_Regulations_Value = request.Amount.mul(request.WACEO_Regulations._amount.div(10**IERC20(Waceo).decimals())).div(100);
uint256 _WACEO_Unrekt_Value = request.Amount.mul(request.WACEO_Unrekt._amount.div(10**IERC20(Waceo).decimals())).div(100);
IERC20(Waceo).mint(request.LP_Controller._address, _LP_Controller_Value);
IERC20(Waceo).mint(request.Founding_Team._address, _Founding_Team_Value);
IERC20(Waceo).mint(request.WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
IERC20(Waceo).mint(request.WACEO_Operational._address, _WACEO_Operational_Value);
IERC20(Waceo).mint(request.WACEO_Dev._address, _WACEO_Dev_Value);
IERC20(Waceo).mint(request.WACEO_Regulations._address, _WACEO_Regulations_Value);
IERC20(Waceo).mint(request.WACEO_Unrekt._address, _WACEO_Unrekt_Value);
request.Approved = true;
return true;
}
function tokenPriceInUSD(address _token, address _lp, uint256 _amount) public view returns (uint256 _tokenValueInWAVAX, uint256 _tokenValueInUSD) {
require(_token != address(0), "Wrong token address");
require(_lp != address(0), "Wrong LP address");
require(_amount > 0, "Wrong amount");
uint256 _wavaxValue = IERC20(Wavax).balanceOf(_lp).div(10** IERC20(Wavax).decimals()).mul(10** IERC20(Waceo).decimals());
uint256 _tokenValue = IERC20(_token).balanceOf(_lp).div(10** IERC20(_lp).decimals()).mul(10** IERC20(Waceo).decimals());
_tokenValueInWAVAX = _wavaxValue.mul(10** IERC20(Waceo).decimals()).div(_tokenValue);
uint256 _wavaxPriceInUSD = wavaxPriceInUSD();
_tokenValueInUSD = _tokenValueInWAVAX.mul(_wavaxPriceInUSD).div(10** IERC20(Waceo).decimals());
}
function waceoPriceInUSD() public view returns (uint256 price_) {
uint256 _waceoInWAVAX = waceoPriceInWAVAX();
uint256 _wavaxInUSD = wavaxPriceInUSD();
price_ = _waceoInWAVAX.mul(_wavaxInUSD).div(10** IERC20(Waceo).decimals());
}
function waceoPriceInWAVAX() public view returns (uint256 price_) {
uint256 _wavaxValue = IERC20(Wavax).balanceOf(WAVAX_WACEO_LP).div(10** IERC20(Wavax).decimals()).mul(10** IERC20(Waceo).decimals());
uint256 _waceoValue = IERC20(Waceo).balanceOf(WAVAX_WACEO_LP);
price_ = _wavaxValue.mul(10** IERC20(Waceo).decimals()).div(_waceoValue);
}
function wavaxPriceInUSD() public view returns (uint256 price_) {
uint256 _wavaxValue = IERC20(Wavax).balanceOf(WAVAX_STABLE_LP).div(10** IERC20(Wavax).decimals()).mul(10** IERC20(Waceo).decimals());
uint256 _stableValue = IERC20(Stable).balanceOf(WAVAX_STABLE_LP).div(10** IERC20(Stable).decimals()).mul(10** IERC20(Waceo).decimals());
price_ = _stableValue.mul(10** IERC20(Waceo).decimals()).div(_wavaxValue);
}
}
| 129,449 | 20 |
c0961ff1a293a6ec67c00b15a384d78e480481ff209cddb0147384f2d050acdd
| 10,767 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcd2a5c39b13b2c27b2ed1f51eef17d5f646563d2.sol
| 3,032 | 10,642 |
pragma solidity 0.4.21;
// Wolf Crypto presale pooling contract
// written by @iamdefinitelyahuman
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) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20 {
function balanceOf(address _owner) external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
}
interface WhiteList {
function checkMemberLevel (address addr) external view returns (uint);
}
library PresaleLib {
using SafeMath for uint;
WhiteList constant whitelistContract = WhiteList(0x8D95B038cA80A986425FA240C3C17Fb2B6e9bc63);
uint constant contributionMin = 100000000000000000;
uint constant maxGasPrice = 50000000000;
struct Contributor {
uint16 claimedTokensIndex;
uint balance;
}
struct Data {
address owner;
address receiver;
address[] withdrawToken;
bool poolSubmitted;
bool locked;
uint addressSetTime;
uint fee;
uint contractCap;
uint finalBalance;
uint[] withdrawAmount;
uint[] capAmounts;
uint32[] capTimes;
mapping (address => uint) tokenBalances;
mapping (address => uint) individualCaps;
mapping (address => Contributor) contributorMap;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event ReceiverAddressSet (address addr);
event PoolSubmitted (address receiver, uint amount);
event WithdrawalAvailable (address token);
event WithdrawalClaimed (address receiver, address token, uint amount);
modifier onlyOwner (Data storage self) {
require (msg.sender == self.owner);
_;
}
modifier noReentrancy(Data storage self) {
require(!self.locked);
self.locked = true;
_;
self.locked = false;
}
function _toPct (uint numerator, uint denominator) internal pure returns (uint) {
return numerator.mul(10 ** 20).div(denominator);
}
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct).div(10 ** 20);
}
function newPool (Data storage self, uint _fee, address _receiver, uint _contractCap, uint _individualCap) public {
require (_fee < 1000);
self.owner = msg.sender;
self.receiver = _receiver;
self.contractCap = _contractCap;
self.capTimes.push(0);
self.capAmounts.push(_individualCap);
self.fee = _toPct(_fee,1000);
}
function deposit (Data storage self) public {
assert (!self.poolSubmitted);
require (tx.gasprice <= maxGasPrice);
Contributor storage c = self.contributorMap[msg.sender];
uint cap = _getCap(self, msg.sender);
require (cap >= c.balance.add(msg.value));
if (self.contractCap < address(this).balance) {
require (address(this).balance.sub(msg.value) < self.contractCap);
uint excess = address(this).balance.sub(self.contractCap);
c.balance = c.balance.add(msg.value.sub(excess));
msg.sender.transfer(excess);
} else {
c.balance = c.balance.add(msg.value);
}
require (c.balance >= contributionMin);
emit ContributorBalanceChanged(msg.sender, c.balance);
}
function receiveRefund (Data storage self) public {
assert (self.poolSubmitted);
require (msg.sender == self.receiver || msg.sender == self.owner);
require (msg.value >= 1 ether);
self.withdrawToken.push(0x00);
self.withdrawAmount.push(msg.value);
emit WithdrawalAvailable(0x00);
}
function withdraw (Data storage self) public {
assert (msg.value == 0);
Contributor storage c = self.contributorMap[msg.sender];
require (c.balance > 0);
if (!self.poolSubmitted) {
uint balance = c.balance;
c.balance = 0;
msg.sender.transfer(balance);
emit ContributorBalanceChanged(msg.sender, 0);
return;
}
require (c.claimedTokensIndex < self.withdrawToken.length);
uint pct = _toPct(c.balance,self.finalBalance);
uint amount;
address token;
for (uint16 i = c.claimedTokensIndex; i < self.withdrawToken.length; i++) {
amount = _applyPct(self.withdrawAmount[i],pct);
token = self.withdrawToken[i];
c.claimedTokensIndex++;
if (amount > 0) {
if (token == 0x00) {
msg.sender.transfer(amount);
} else {
require (ERC20(token).transfer(msg.sender, amount));
self.tokenBalances[token] = self.tokenBalances[token].sub(amount);
}
emit WithdrawalClaimed(msg.sender, token, amount);
}
}
}
function setIndividualCaps (Data storage self, address[] addr, uint[] cap) public onlyOwner(self) {
require (addr.length == cap.length);
for (uint8 i = 0; i < addr.length; i++) {
self.individualCaps[addr[i]] = cap[i];
}
}
function setCaps (Data storage self, uint32[] times, uint[] caps) public onlyOwner(self) {
require (caps.length > 0);
require (caps.length == times.length);
self.capTimes = [0];
self.capAmounts = [self.capAmounts[0]];
for (uint8 i = 0; i < caps.length; i++) {
require (times[i] > self.capTimes[self.capTimes.length.sub(1)]);
self.capTimes.push(times[i]);
self.capAmounts.push(caps[i]);
}
}
function setContractCap (Data storage self, uint amount) public onlyOwner(self) {
require (amount >= address(this).balance);
self.contractCap = amount;
}
function _getCap (Data storage self, address addr) internal view returns (uint) {
if (self.individualCaps[addr] > 0) return self.individualCaps[addr];
if (whitelistContract.checkMemberLevel(msg.sender) == 0) return 0;
return getCapAtTime(self,now);
}
function getCapAtTime (Data storage self, uint time) public view returns (uint) {
if (time == 0) time = now;
for (uint i = 1; i < self.capTimes.length; i++) {
if (self.capTimes[i] > time) return self.capAmounts[i-1];
}
return self.capAmounts[self.capAmounts.length-1];
}
function getPoolInfo (Data storage self) view public returns (uint balance, uint remaining, uint cap) {
if (!self.poolSubmitted) return (address(this).balance, self.contractCap.sub(address(this).balance), self.contractCap);
return (address(this).balance, 0, self.contractCap);
}
function getContributorInfo (Data storage self, address addr) view public returns (uint balance, uint remaining, uint cap) {
cap = _getCap(self, addr);
Contributor storage c = self.contributorMap[addr];
if (self.poolSubmitted || cap <= c.balance) return (c.balance, 0, cap);
if (cap.sub(c.balance) > self.contractCap.sub(address(this).balance)) return (c.balance, self.contractCap.sub(address(this).balance), cap);
return (c.balance, cap.sub(c.balance), cap);
}
function checkWithdrawalAvailable (Data storage self, address addr) view public returns (bool) {
return self.contributorMap[addr].claimedTokensIndex < self.withdrawToken.length;
}
function setReceiverAddress (Data storage self, address _receiver) public onlyOwner(self) {
require (!self.poolSubmitted);
self.receiver = _receiver;
self.addressSetTime = now;
emit ReceiverAddressSet(_receiver);
}
function submitPool (Data storage self, uint amountInWei) public onlyOwner(self) noReentrancy(self) {
require (!self.poolSubmitted);
require (now > self.addressSetTime.add(86400));
if (amountInWei == 0) amountInWei = address(this).balance;
self.finalBalance = address(this).balance;
self.poolSubmitted = true;
require (self.receiver.call.value(amountInWei).gas(gasleft().sub(5000))());
if (address(this).balance > 0) {
self.withdrawToken.push(0x00);
self.withdrawAmount.push(address(this).balance);
emit WithdrawalAvailable(0x00);
}
emit PoolSubmitted(self.receiver, amountInWei);
}
function enableWithdrawals (Data storage self, address tokenAddress, address feeAddress) public onlyOwner(self) noReentrancy(self) {
require (self.poolSubmitted);
if (feeAddress == 0x00) feeAddress = self.owner;
ERC20 token = ERC20(tokenAddress);
uint amount = token.balanceOf(this).sub(self.tokenBalances[tokenAddress]);
require (amount > 0);
if (self.fee > 0) {
require (token.transfer(feeAddress, _applyPct(amount,self.fee)));
amount = token.balanceOf(this).sub(self.tokenBalances[tokenAddress]);
}
self.tokenBalances[tokenAddress] = token.balanceOf(this);
self.withdrawToken.push(tokenAddress);
self.withdrawAmount.push(amount);
emit WithdrawalAvailable(tokenAddress);
}
}
contract PresalePool {
using PresaleLib for PresaleLib.Data;
PresaleLib.Data data;
event ERC223Received (address token, uint value, bytes data);
function PresalePool (uint fee, address receiver, uint contractCap, uint individualCap) public {
data.newPool(fee, receiver, contractCap, individualCap);
}
function () public payable {
if (msg.value > 0) {
if (!data.poolSubmitted) {
data.deposit();
} else {
data.receiveRefund();
}
} else {
data.withdraw();
}
}
function setIndividualCaps (address[] addr, uint[] cap) public {
data.setIndividualCaps(addr, cap);
}
function setCaps (uint32[] times, uint[] caps) public {
data.setCaps(times,caps);
}
function setContractCap (uint amount) public {
data.setContractCap(amount);
}
function getPoolInfo () view public returns (uint balance, uint remaining, uint cap) {
return data.getPoolInfo();
}
function getContributorInfo (address addr) view public returns (uint balance, uint remaining, uint cap) {
return data.getContributorInfo(addr);
}
function getCapAtTime (uint32 time) view public returns (uint) {
return data.getCapAtTime(time);
}
function checkWithdrawalAvailable (address addr) view public returns (bool) {
return data.checkWithdrawalAvailable(addr);
}
function setReceiverAddress (address receiver) public {
data.setReceiverAddress(receiver);
}
function submitPool (uint amountInWei) public {
data.submitPool(amountInWei);
}
function enableWithdrawals (address tokenAddress, address feeAddress) public {
data.enableWithdrawals(tokenAddress, feeAddress);
}
function tokenFallback (address from, uint value, bytes calldata) public {
emit ERC223Received(from, value, calldata);
}
}
| 210,119 | 21 |
0adde36f72e0a129537bf6afa41dc6581e1a05ab99f2d4d9acc01b89baa232e0
| 23,414 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTJdgX8paJntHFpWv4LMtZPZAt2anSQiA1_SpecialTron.sol
| 6,657 | 22,813 |
//SourceUnit: SpecialTron.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
uint256 timer;
uint256 turnover;
uint256 currentLevel;
uint256 bonusEarnings;
}
struct Bonus {
uint256 gap;
uint256 prize;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract SpecialTron is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 60; // 6 %
uint256 public constant MARKETING_RATE = 60; // 6 %
uint256 public constant ADMIN_RATE = 20; // 2 %
uint256 public constant REFERENCE_RATE = 150; // 15 % Total
uint256 public constant REFERENCE_LEVEL1_RATE = 50; // 5 %
uint256 public constant REFERENCE_LEVEL2_RATE = 40; // 4 %
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3 %
uint256 public constant REFERENCE_LEVEL4_RATE = 20; // 2 %
uint256 public constant REFERENCE_LEVEL5_RATE = 10; // 1 %
uint256 public constant ACTIVATION_TIME = 1606845600;
uint256 public constant MINIMUM = 50000000; // Minimum 50 Tron
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private adminAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
mapping(uint256 => Objects.Bonus) public bonusLevels;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = address(0xE4b5d489258E6239E6811536A178811ec6f7505b);
adminAccount_ = address(0xD468596D5F8C4a9f82B98680621ab1022b6c24C5);
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(100, 12*60*60*24)); // 120 % Return
investmentPlans_.push(Objects.Plan(150, 10*60*60*24)); // 150 % Return
investmentPlans_.push(Objects.Plan(200, 8*60*60*24)); // 160 % Return
investmentPlans_.push(Objects.Plan(280, 7*60*60*24)); // 196 % Return
bonusLevels[1] = Objects.Bonus(10000*1e6,150*1e6);
bonusLevels[2] = Objects.Bonus(15000*1e6,350*1e6);
bonusLevels[3] = Objects.Bonus(50000*1e6,800*1e6);
bonusLevels[4] = Objects.Bonus(100000*1e6,2000*1e6);
bonusLevels[5] = Objects.Bonus(500000*1e6,10000*1e6);
bonusLevels[6] = Objects.Bonus(1000000*1e6,22000*1e6);
bonusLevels[7] = Objects.Bonus(5000000*1e6,125000*1e6);
bonusLevels[8] = Objects.Bonus(10000000*1e6,305000*1e6);
bonusLevels[9] = Objects.Bonus(15000000*1e6,1000000*1e6);
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getTimer(address _addr) public view returns (uint256) {
return uid2Investor[address2UID[_addr]].timer;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] memory, uint256[] memory,uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory refStats = new uint256[](2);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
refStats[0] = investor.turnover;
refStats[1] = investor.bonusEarnings;
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
investor.planCount,
currentDividends,
newDividends,
refStats);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(ACTIVATION_TIME < now , "NOT_YET_LAUNCHED");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
uint256 adminPercentage = (_amount.mul(ADMIN_RATE)).div(1000);
adminAccount_.transfer(adminPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
require(uid2Investor[uid].timer < now, "withdrawal is available only once every 48 hours");
uid2Investor[uid].timer = now + 48 hours;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].turnover = _investment.add(uid2Investor[_ref1].turnover);
if(uid2Investor[_ref1].currentLevel < 9 && bonusLevels[uid2Investor[_ref1].currentLevel + 1].gap <= uid2Investor[_ref1].turnover){
uid2Investor[_ref1].availableReferrerEarnings = bonusLevels[uid2Investor[_ref1].currentLevel + 1].prize.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].currentLevel++;
uid2Investor[_ref1].bonusEarnings = bonusLevels[uid2Investor[_ref1].currentLevel].prize.add(uid2Investor[_ref1].bonusEarnings);
}
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].turnover = (_investment.div(2)).add(uid2Investor[_ref2].turnover);
if(uid2Investor[_ref2].currentLevel < 9 && bonusLevels[uid2Investor[_ref2].currentLevel + 1].gap <= uid2Investor[_ref2].turnover){
uid2Investor[_ref2].availableReferrerEarnings = bonusLevels[uid2Investor[_ref2].currentLevel + 1].prize.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].currentLevel++;
uid2Investor[_ref2].bonusEarnings = bonusLevels[uid2Investor[_ref2].currentLevel].prize.add(uid2Investor[_ref2].bonusEarnings);
}
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].turnover = (_investment.div(4)).add(uid2Investor[_ref3].turnover);
if(uid2Investor[_ref3].currentLevel < 9 && bonusLevels[uid2Investor[_ref3].currentLevel + 1].gap <= uid2Investor[_ref3].turnover){
uid2Investor[_ref3].availableReferrerEarnings = bonusLevels[uid2Investor[_ref3].currentLevel + 1].prize.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].currentLevel++;
uid2Investor[_ref3].bonusEarnings = bonusLevels[uid2Investor[_ref3].currentLevel].prize.add(uid2Investor[_ref3].bonusEarnings);
}
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].turnover = (_investment.div(10)).add(uid2Investor[_ref4].turnover);
if(uid2Investor[_ref4].currentLevel < 9 && bonusLevels[uid2Investor[_ref4].currentLevel + 1].gap <= uid2Investor[_ref4].turnover){
uid2Investor[_ref4].availableReferrerEarnings = bonusLevels[uid2Investor[_ref4].currentLevel + 1].prize.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].currentLevel++;
uid2Investor[_ref4].bonusEarnings = bonusLevels[uid2Investor[_ref4].currentLevel].prize.add(uid2Investor[_ref4].bonusEarnings);
}
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].turnover = (_investment.div(20)).add(uid2Investor[_ref5].turnover);
if(uid2Investor[_ref5].currentLevel < 9 && bonusLevels[uid2Investor[_ref5].currentLevel + 1].gap <= uid2Investor[_ref5].turnover){
uid2Investor[_ref5].availableReferrerEarnings = bonusLevels[uid2Investor[_ref5].currentLevel + 1].prize.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].currentLevel++;
uid2Investor[_ref5].bonusEarnings = bonusLevels[uid2Investor[_ref5].currentLevel].prize.add(uid2Investor[_ref5].bonusEarnings);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 287,253 | 22 |
ec0097aa6206f43738a2a4720531ca85923261dd4dc919f7326467ea75e5c72d
| 13,903 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6e50a486ca037e92ccb3a5ab3d084626b546c9c0.sol
| 3,026 | 11,408 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
assert(z / x == y);
return z;
}
function div(uint256 x, uint256 y) internal pure returns (uint256) {
// assert(y > 0);//Solidity automatically throws when dividing by 0
uint256 z = x / y;
// assert(x == y * z + x % y); // There is no case in which this doesn`t hold
return z;
}
function sub(uint256 x, uint256 y) internal pure returns (uint256) {
assert(y <= x);
return x - y;
}
function add(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
assert(z >= x);
return z;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner !=address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) <<16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract ERC223 {
uint public totalSupply;
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract QSHU is ERC223, Ownable {
using SafeMath for uint256;
string public name = "QSHUCOIN";
string public symbol = "QSHU";
uint8 public decimals = 8;
uint256 public initialSupply = 50e9 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping (address => uint) balances;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed burner, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function QSHU() public {
totalSupply = initialSupply;
balances[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
modifier onlyPayloadSize(uint256 size){
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint q = 0; q < targets.length; q++) {
require(targets[q] != 0x0);
frozenAccount[targets[q]] = isFrozen;
emit FrozenFunds(targets[q], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint q = 0; q < targets.length; q++){
require(unlockUnixTime[targets[q]] < unixTimes[q]);
unlockUnixTime[targets[q]] = unixTimes[q];
emit LockedFunds(targets[q], unixTimes[q]);
}
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf(_from) >= _unitAmount);
balances[_from] = SafeMath.sub(balances[_from], _unitAmount);
totalSupply = SafeMath.sub(totalSupply, _unitAmount);
emit Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint (address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = SafeMath.add(totalSupply, _unitAmount);
balances[_to] = SafeMath.add(balances[_to], _unitAmount);
emit Mint(_to, _unitAmount);
emit Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function distributeTokens(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = SafeMath.mul(amount,1e8);
uint256 totalAmount = SafeMath.mul(amount, addresses.length);
require(balances[msg.sender] >= totalAmount);
for (uint q = 0; q < addresses.length; q++) {
require(addresses[q] != 0x0
&& frozenAccount[addresses[q]] == false
&& now > unlockUnixTime[addresses[q]]);
balances[addresses[q]] = SafeMath.add(balances[addresses[q]], amount);
emit Transfer(msg.sender, addresses[q], amount);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender],totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint q = 0; q < addresses.length; q++) {
require(amounts[q] > 0
&& addresses[q] != 0x0
&& frozenAccount[addresses[q]] == false
&& now > unlockUnixTime[addresses[q]]);
amounts[q] = SafeMath.mul(amounts[q], 1e8);
require(balances[addresses[q]] >= amounts[q]);
balances[addresses[q]] = SafeMath.sub(balances[addresses[q]], amounts[q]);
totalAmount = SafeMath.add(totalAmount, amounts[q]);
emit Transfer(addresses[q], msg.sender, amounts[q]);
}
balances[msg.sender] = SafeMath.add(balances[msg.sender], totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf(owner) >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if (msg.value > 0) owner.transfer(msg.value);
balances[owner] = SafeMath.sub(balances[owner], distributeAmount);
balances[msg.sender] = SafeMath.add(balances[msg.sender], distributeAmount);
emit Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
/**
* My thought is strong!
* The reconstruction of Kyusyu is the power of everyone!
function destroy() public {
for(uint i = 0; i < values.length - 1; i++) {
if(entries[values[i]].expires != 0)
throw;
msg.sender.send(msg.value);
}
}
}
| 179,115 | 23 |
322f2bf6fe7f508bc5f6ceef679f7698f9c8f53b1844703fd600515d9a34f653
| 10,167 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x182fad6a68ebd9118549ec1091aa4eb95e234ef6.sol
| 3,313 | 9,949 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract POWHclone {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "ProofOfWeakHands";
string constant public symbol = "POWH";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
address owner;
function POWHclone() public {
owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
selfdestruct(owner);
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 201,476 | 24 |
e004054a7c7f0c0f149feb6e30707ab876172e12b3b509033265ce34b5954313
| 14,328 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/wastefulContracts/0x42ab724e2a6a75930d6735189fc4f7b2edaffc72_wastefulContract.sol
| 3,845 | 13,298 |
pragma solidity ^0.5.8;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
address public ceoAddress = address(0xFce92D4163AA532AA096DE8a3C4fEf9f875Bc55F);
IERC721 public erc721Address = IERC721(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 25; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 2000000000000000;
uint256 public limitHBWALLETFee = 2;
uint256 public hightLightFee = 30000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(true);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i = index; i<arrayTokenIdSale.length-1; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint[] memory arr) internal {
for(uint i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint256 _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
ethNeed = ethfee + _hightLightFee;
} else {
ethNeed = limitETHFee + _hightLightFee;
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable {
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee + _hightLightFee);
} else {
require(msg.value == limitETHFee + _hightLightFee);
ethfee = limitETHFee;
}
}
ethfee += prices[_tokenId].fee;
} else ethfee = _ethPrice * ETHFee / Percen;
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1 ? true : false);
}
function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint256 fee;
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
hbNeed = fee + _hightLightFee;
} else {
hbNeed = limitHBWALLETFee + _hightLightFee;
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public returns (bool){
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 fee;
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee + _hightLightFee));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee + _hightLightFee));
fee = limitHBWALLETFee;
}
}
fee += prices[_tokenId].hbfee;
} else {
ethfee = _ethPrice * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1 ? true : false);
return true;
}
function removePrice(uint256 tokenId) public returns (uint256){
require(erc721Address.ownerOf(tokenId) == msg.sender);
if (prices[tokenId].fee > 0) msg.sender.transfer(prices[tokenId].fee);
else if (prices[tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[tokenId].hbfee);
resetPrice(tokenId);
return prices[tokenId].price;
}
function setFee(uint256 _ethFee, uint256 _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint256, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint256 _hbWalletlimitFee) public onlyOwner returns (uint256, uint256){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(address payable _address, uint256 amount, uint256 _amountHB) internal {
require(_address != address(0) && amount >= 0 && address(this).balance >= amount && _amountHB >= 0 && hbwalletToken.balanceOf(address(this)) >= _amountHB);
_address.transfer(amount);
hbwalletToken.transferFrom(address(this), _address, _amountHB);
}
function withdraw(address payable _address, uint256 amount, uint256 _amountHB) public onlyCeoAddress {
_withdraw(_address, amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
uint256 eth = prices[arrayTokenIdSale[i]].fee;
if(prices[arrayTokenIdSale[i]].isHightlight == true) eth += hightLightFee;
if(address(this).balance >= eth) {
prices[arrayTokenIdSale[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
uint256 hb = prices[arrayTokenIdSale[i]].hbfee;
if(prices[arrayTokenIdSale[i]].isHightlight == true) hb += hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arrayTokenIdSale[i]].tokenOwner, hb);
}
}
}
}
_withdraw(msg.sender, address(this).balance, hbwalletToken.balanceOf(address(this)));
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
function revenue(bool _isEth) public view returns (uint256){
uint256 ethfee = 0;
uint256 hbfee = 0;
for (uint256 i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee += prices[arrayTokenIdSale[i]].fee;
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee += prices[arrayTokenIdSale[i]].hbfee;
}
}
}
uint256 eth = address(this).balance - ethfee;
uint256 hb = hbwalletToken.balanceOf(address(this)) - hbfee;
return _isEth ? eth : hb;
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(true);
require(true);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(true);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint256 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
}
| 278,393 | 25 |
2b311a699ce0df7ea29ba9d3cf5e9836f0c83ea0e71bc85283dc1f6e4dda620f
| 10,525 |
.sol
|
Solidity
| false |
363993391
|
gasgauge/gasgauge.github.io
|
7795ecd73e31b875fb199c36a74ab8ecd74f870d
|
Benchmark/no loops/0xd0501e2c8e603b3f48a9a6283dc9744068b843b7.sol
| 2,842 | 10,214 |
pragma solidity >=0.5 <0.7.17;
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 Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public y ; //Token
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor (IERC20 ierc20) internal {
y = ierc20;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
y.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
y.safeTransfer(msg.sender, amount);
}
}
contract PoolReward is LPTokenWrapper {
IERC20 public rewardtoken = IERC20(0);
uint256 public constant oneday = 1 days;
uint256 public initreward = 0;
uint256 public starttime = 0;
uint256 public endtime = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime = 0;
uint256 public rewardPerTokenStored = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
constructor(address _lptoken,address _rewardtoken,uint256 _initreward,uint256 _starttime,uint256 _duration) LPTokenWrapper(IERC20(_lptoken)) public{
rewardtoken = IERC20(_rewardtoken);
starttime = _starttime;
lastUpdateTime = starttime;
initreward = _initreward;
endtime = starttime.add(oneday.mul(_duration));
rewardRate = initreward.div(oneday.mul(_duration));
}
modifier updateReward(address account) {
if(lastTimeRewardApplicable() > starttime && totalSupply() != 0){
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, endtime);
}
function rewardPerToken() public view returns (uint256) {
if ((block.timestamp < starttime) || (totalSupply() == 0)) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardtoken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
}
| 341,964 | 26 |
6e5e1f1728f211dafb49f16e67f760b29f5a9cac4fc6f05ab3edd6b9a22bb63b
| 25,460 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x96b6A0fAF7ab3E03757f60E808BB771E7761e014/contract.sol
| 5,420 | 18,932 |
pragma solidity 0.8.1;
// SPDX-License-Identifier: MIT
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
}
contract UNI_WBNB_Pool is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint256 amount);
// TENFI token contract address
address public tokenAddress = 0x081B2aEB9925e1F72e889eac10516C2A48a9F76a;
// LP token contract address
address public LPtokenAddress = 0x4269e7F43A63CEA1aD7707Be565a94a9189967E9;
// reward rate 200 % per year
uint256 public rewardRate = 354176;
uint256 public rewardInterval = 365 days;
// unstaking possible after 0 days
uint256 public cliffTime = 0 days;
uint256 public farmEnableat;
uint256 public totalClaimedRewards = 0;
uint256 public totalDevFee = 0;
uint256 private stakingAndDaoTokens = 100000e18;
bool public farmEnabled = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint256) public depositedTokens;
mapping (address => uint256) public stakingTime;
mapping (address => uint256) public lastClaimedTime;
mapping (address => uint256) public totalEarnedTokens;
function updateAccount(address account) private {
uint256 pendingDivs = getPendingDivs(account);
uint256 fee = pendingDivs.mul(2000).div(1e4);
uint256 pendingDivsAfterFee = pendingDivs.sub(fee);
if (pendingDivsAfterFee > 0) {
require(Token(tokenAddress).transfer(account, pendingDivsAfterFee), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivsAfterFee);
totalClaimedRewards = totalClaimedRewards.add(pendingDivsAfterFee);
emit RewardsTransferred(account, pendingDivsAfterFee);
}
if (fee > 0) {
require(Token(tokenAddress).transfer(account, fee), "Could not transfer tokens.");
totalDevFee = totalDevFee.add(fee);
emit RewardsTransferred(account, fee);
}
lastClaimedTime[account] = block.timestamp;
}
function getPendingDivs(address _holder) public view returns (uint256 _pendingDivs) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint256 timeDiff = block.timestamp.sub(lastClaimedTime[_holder]);
uint256 stakedAmount = depositedTokens[_holder];
if (block.timestamp <= farmEnableat + 1 days) {
uint256 pendingDivs = stakedAmount.mul(4003444).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 1 days && block.timestamp <= farmEnableat + 2 days) {
uint256 pendingDivs = stakedAmount.mul(3680892).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 2 days && block.timestamp <= farmEnableat + 3 days) {
uint256 pendingDivs = stakedAmount.mul(3389962).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 3 days && block.timestamp <= farmEnableat + 4 days) {
uint256 pendingDivs = stakedAmount.mul(3118006).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 4 days && block.timestamp <= farmEnableat + 5 days) {
uint256 pendingDivs = stakedAmount.mul(2865024).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 5 days && block.timestamp <= farmEnableat + 6 days) {
uint256 pendingDivs = stakedAmount.mul(2637340).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 6 days && block.timestamp <= farmEnableat + 7 days) {
uint256 pendingDivs = stakedAmount.mul(2428630).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 7 days && block.timestamp <= farmEnableat + 8 days) {
uint256 pendingDivs = stakedAmount.mul(2232569).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 8 days && block.timestamp <= farmEnableat + 9 days) {
uint256 pendingDivs = stakedAmount.mul(2055481).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 9 days && block.timestamp <= farmEnableat + 10 days) {
uint256 pendingDivs = stakedAmount.mul(1891043).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 10 days && block.timestamp <= farmEnableat + 11 days) {
uint256 pendingDivs = stakedAmount.mul(1739253).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 11 days && block.timestamp <= farmEnableat + 12 days) {
uint256 pendingDivs = stakedAmount.mul(1600113).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 12 days && block.timestamp <= farmEnableat + 13 days) {
uint256 pendingDivs = stakedAmount.mul(1473622).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 13 days && block.timestamp <= farmEnableat + 14 days) {
uint256 pendingDivs = stakedAmount.mul(1353455).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 14 days && block.timestamp <= farmEnableat + 15 days) {
uint256 pendingDivs = stakedAmount.mul(1245938).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 15 days && block.timestamp <= farmEnableat + 16 days) {
uint256 pendingDivs = stakedAmount.mul(1144745).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 16 days && block.timestamp <= farmEnableat + 17 days) {
uint256 pendingDivs = stakedAmount.mul(1056201).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 17 days && block.timestamp <= farmEnableat + 18 days) {
uint256 pendingDivs = stakedAmount.mul(967657).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 18 days && block.timestamp <= farmEnableat + 19 days) {
uint256 pendingDivs = stakedAmount.mul(891763).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 19 days && block.timestamp <= farmEnableat + 20 days) {
uint256 pendingDivs = stakedAmount.mul(828517).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 20 days && block.timestamp <= farmEnableat + 21 days) {
uint256 pendingDivs = stakedAmount.mul(752623).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 21 days && block.timestamp <= farmEnableat + 22 days) {
uint256 pendingDivs = stakedAmount.mul(695702).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 22 days && block.timestamp <= farmEnableat + 23 days) {
uint256 pendingDivs = stakedAmount.mul(638781).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 23 days && block.timestamp <= farmEnableat + 24 days) {
uint256 pendingDivs = stakedAmount.mul(588184).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 24 days && block.timestamp <= farmEnableat + 25 days) {
uint256 pendingDivs = stakedAmount.mul(543912).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 25 days && block.timestamp <= farmEnableat + 26 days) {
uint256 pendingDivs = stakedAmount.mul(499640).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 26 days && block.timestamp <= farmEnableat + 27 days) {
uint256 pendingDivs = stakedAmount.mul(455368).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 27 days && block.timestamp <= farmEnableat + 28 days) {
uint256 pendingDivs = stakedAmount.mul(423746).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 28 days && block.timestamp <= farmEnableat + 29 days) {
uint256 pendingDivs = stakedAmount.mul(385798).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 29 days && block.timestamp <= farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(354176).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(rewardRate).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
}
}
function getNumberOfHolders() public view returns (uint256) {
return holders.length();
}
function deposit(uint256 amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(farmEnabled, "Farming is not enabled");
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToStake);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint256 amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(block.timestamp.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimDivs() public {
updateAccount(msg.sender);
}
function getStakingAndDaoAmount() public view returns (uint256) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint256 remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
function setTokenAddress(address _tokenAddressess) public onlyOwner {
tokenAddress = _tokenAddressess;
}
function setCliffTime(uint256 _time) public onlyOwner {
cliffTime = _time;
}
function setRewardInterval(uint256 _rewardInterval) public onlyOwner {
rewardInterval = _rewardInterval;
}
function setStakingAndDaoTokens(uint256 _stakingAndDaoTokens) public onlyOwner {
stakingAndDaoTokens = _stakingAndDaoTokens;
}
function setRewardRate(uint256 _rewardRate) public onlyOwner {
rewardRate = _rewardRate;
}
function enableFarming() external onlyOwner() {
farmEnabled = true;
farmEnableat = block.timestamp;
}
// function to allow admin to claim *any* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
require(_tokenAddress != LPtokenAddress);
Token(_tokenAddress).transfer(_to, _amount);
}
}
| 255,787 | 27 |
ac79328d76ded1010b7b3f4ab7f9f37abf37909fdd96318d2c2b895ae06c952f
| 28,107 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGZ8jfoKSqWsD3GERWfqsYVz3KngtPKenh_RKTXBridge.sol
| 3,180 | 12,266 |
//SourceUnit: TronBridge.sol
// SPDX-License-Identifier: MIT
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 _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 ERC20 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() public {
_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 _transfer(address sender,
address recipient,
uint256 amount) internal virtual{
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _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);
}
}
contract RKTXBridge{
uint256 minAmount = 10 ** 2 * 10 ** 18;
ERC20 erc20;
address public ownerAddress;
event _transferBscTronRKTX(address sender, string receiver, uint256 amount);
event _transferTronBscRKTX(address account, string receiver, uint256 amount);
event _transferToUser(address account, uint256 amount);
constructor(ERC20 _erc20) public {
erc20 = _erc20;
ownerAddress = msg.sender;
}
modifier onlyOwner() {
require(ownerAddress == msg.sender, 'Ownable: caller is not the owner');
_;
}
function transferBscTronRKTX(string memory receiver, uint256 amount) payable public {
require(amount > 0, "Can not transfer zero amount");
require(amount >= minAmount, "Invalid tranfer amount");
payable(ownerAddress).transfer(address(this).balance); // send fee to owner
erc20.transferFrom(msg.sender, address(this), amount);
emit _transferBscTronRKTX(msg.sender, receiver, amount);
}
function transferTronBscRKTX(string memory receiver, uint256 amount) payable public {
require(amount > 0, "Can not transfer zero amount");
require(amount >= minAmount, "Invalid tranfer amount");
payable(ownerAddress).transfer(address(this).balance); // send fee to owner
erc20.transferFrom(msg.sender, address(this), amount);
emit _transferTronBscRKTX(msg.sender, receiver, amount);
}
function transferToUser(address account, uint256 amount) public onlyOwner{
erc20.transfer(account, amount);
emit _transferToUser(account, amount);
}
function transferOwnership(address newOwner) public onlyOwner{
ownerAddress = newOwner;
}
}
| 298,771 | 28 |
19a4e16e10b17297747e5d1e5d634c55889202a9c0964ca0bcec735f6c6804eb
| 29,430 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ed/edc2173d4c1b4225385ba2079f927337abb90dc0_Staking3Months.sol
| 3,776 | 15,310 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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
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");
}
}
}
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);
}
}
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());
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
contract Staking3Months is Ownable, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
//mapping(address => uint256) private _stakes;
struct Deposit{
uint256 depositedAt;
uint256 depositedQty;
bool isWithdrawn;
}
mapping(address => Deposit[]) public deposits;
uint256 public depositTime; //= 180 days;
uint256 public stakedTotal;
address public rewardAddress;
bool private depositEnabled = true;
IERC20 immutable token;
event Staked(address indexed token,
address indexed staker_,
uint256 requestedAmount_
//uint256 stakedAmount_);
event PaidOut(address indexed token,
address indexed staker_,
uint256 amount_,
uint256 reward_);
event DepositToggled(bool value);
event DepositTimeSet(uint256 value);
event RewardPercSet(uint256 value);
event RewardAddressChanged(address indexed sender,
address indexed rewardAddress);
modifier _after(uint256 eventTime) {
require(block.timestamp >= eventTime,
"Error: bad timing for the request");
_;
}
modifier _before(uint256 eventTime) {
require(block.timestamp < eventTime,
"Error: bad timing for the request");
_;
}
constructor(address _token, address _rewardAddress, uint256 _depositTime) {
require(_rewardAddress != address(0), "_rewardAddress should not be 0");
token = IERC20(_token);
rewardAddress = _rewardAddress;
depositTime = _depositTime;
}
function getDeposits(address staker) public view returns (Deposit[] memory){
Deposit[] memory d = deposits[staker];
return (d);
}
function withdraw(uint256 id) external{
require(deposits[msg.sender].length > id, "Deposit does not exist"); //make sure that such a deposit exists
require(deposits[msg.sender][id].depositedQty > 0,
"There is nothing to withdraw");
require(block.timestamp >= deposits[msg.sender][id].depositedAt.add(depositTime),
"Staking period not passed yet");
require(deposits[msg.sender][id].isWithdrawn == false);
_withdrawAfterClose(msg.sender, id);
}
//efficiently compute compound
function _compound(uint principle, uint n) private pure returns (uint){
for(uint i=0; i<n; i++){
principle = principle.mul(1000382983).div(1000000000); //15% APY
}
return principle;
}
function _withdrawAfterClose(address from, uint256 id) private {
uint256 amount = deposits[from][id].depositedQty;
uint256 depositedTime = deposits[from][id].depositedAt;
uint256 daysSinceDeposit = (block.timestamp.sub(depositedTime)).div(86400); //get the floored number of days since the deposit
uint256 reward = _compound(amount, daysSinceDeposit);
stakedTotal = stakedTotal.sub(amount);
token.safeTransferFrom(rewardAddress, from, reward); //transfer Reward
//token.safeTransfer(from, amount); //transfer initial stake
emit PaidOut(address(token), from, amount, reward);
deposits[from][id].isWithdrawn = true;
}
function stake(uint256 amount) external whenNotPaused {
require(depositEnabled, "Deposits not enabled");
address staker = msg.sender;
stakedTotal = stakedTotal.add(amount);
deposits[staker].push(Deposit(block.timestamp,
amount,
false));
uint256 allowance = token.allowance(staker, address(this));
require(allowance >= amount, "Check the token allowance");
token.safeTransferFrom(staker, rewardAddress, amount);
emit Staked(address(token), staker, amount);
}
function toggleDeposit() external onlyOwner {
depositEnabled = !depositEnabled;
emit DepositToggled(depositEnabled);
}
function changeRewardAddress(address _address) external onlyOwner {
require(_address != address(0), "Address should not be 0");
rewardAddress = _address;
emit RewardAddressChanged(msg.sender, _address);
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
}
| 91,283 | 29 |
3d8f5bf82834a79943bcf15401687272491b36106dd17963ae03e50fd26a146d
| 13,781 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/TH2cMEsjr7DZ5AsvwhfQ6U44PBDVxtLhFs_ChipGame.sol
| 3,666 | 13,566 |
//SourceUnit: ChipGame.sol
pragma solidity ^0.5.4;
interface Token {
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 burn(uint256 amount) external;
}
interface TokenSale {
function getSoldStep() external view returns (uint steps);
function getRate() external view returns (uint);
}
interface Bank {
function mine(address playerAddr, uint bet) external;
function getMiningRate() external view returns (uint);
}
contract Ownable {
address public owner;
constructor () internal {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
modifier isHuman() {
require(tx.origin == msg.sender, "sorry humans only");
_;
}
}
contract Bonus is Ownable {
struct Dept {
uint tltSpend;
uint tltReceive;
bool alreadyReceive;
}
bool public isBonusReady;
address public bank;
mapping(address => Dept) public userDepts;
event ReceiveBonus(address indexed player, uint dept);
modifier onDeploy() {
require(!isBonusReady, "Bonus was started");
_;
}
modifier ifReady() {
if (isBonusReady) {
_;
}
}
constructor(address _bank) public Ownable() {
bank = _bank;
}
function checkBonus(address player, uint playerTLT) internal ifReady {
if (userDepts[player].tltSpend > 0 && !userDepts[player].alreadyReceive && playerTLT >= userDepts[player].tltSpend) {
userDepts[player].alreadyReceive = true;
uint oneTLT = Bank(bank).getMiningRate() * 10 ** 6;
uint amount = oneTLT * userDepts[player].tltReceive;
Bank(bank).mine(player, amount);
emit ReceiveBonus(player, userDepts[player].tltReceive);
}
}
function setBonus(address player, uint tltSpend, uint tltReceive) external onlyOwner onDeploy {
userDepts[player] = Dept({tltSpend : tltSpend, tltReceive : tltReceive, alreadyReceive : false});
}
function enableBonus() public onlyOwner onDeploy {
isBonusReady = true;
}
}
contract ChipGame is Bonus {
bool isContractEnable;
struct Player {
uint lastPayout;
uint reinvestTime;
uint[] chips;
uint[] buyTime;
uint[] buyMask;
}
address public token;
address public saleContract;
address public bankAddress;
address payable public devWallet;
uint[9] public chipPrice;
uint[9] public chipPayoutPerHour;
uint[9] public chipLifeDays;
uint public playersCount;
mapping(address => Player) public players;
mapping(address => uint) public reinvestMask;
uint public TLTSpent;
uint public TRXReceive;
mapping(address => uint) public TLTSpentOf;
mapping(address => uint) public TRXReceiveOf;
modifier isEnabled() {
require(isContractEnable, "Contract is not enabled");
_;
}
event Donate(address indexed addr, uint amount);
event BuyChip(address indexed addr, uint chip, uint price);
event Payout(address indexed addr, uint amount);
event Reinvest(address indexed addr, uint chip, uint amount);
constructor(address _token, address _bankWallet, address _saleAddress, address payable _devWallet, address _bank) public Bonus(_bank) {
token = _token;
bankAddress = _bankWallet;
saleContract = _saleAddress;
devWallet = _devWallet;
uint tlt = 10000000000;
uint trxValue = 1000000;
chipPrice = [
// First tier chips
160 * tlt, 640 * tlt, 1280 * tlt,
// Second tier chips
704 * tlt, 2816 * tlt, 8448 * tlt,
// Third tier chips
1536 * tlt, 9216 * tlt, 18432 * tlt
];
chipPayoutPerHour = [
// First tier chips
500000, 2 * trxValue, 4 * trxValue,
// Second tier chips
2 * trxValue, 8 * trxValue, 24 * trxValue,
// Third tier chips
4 * trxValue, 24 * trxValue, 48 * trxValue
];
chipLifeDays = [
// First tier chips
40, 40, 40,
// Second tier chips
55, 55, 55,
// Third tier chips
80, 80, 80
];
}
// Setters
function setDevWallet(address payable newWallet) external onlyOwner {
devWallet = newWallet;
}
function setBankAddress(address newWallet) external onlyOwner {
bankAddress = newWallet;
}
function setTokenSaleContract(address newTokenSale) external onlyOwner {
saleContract = newTokenSale;
}
//////////////////////////////////////////////////////////////////////////////////////////////
function getAllPlayerCount() external view returns (uint) {
return playersCount;
}
function getChipsAvailableOf(address user) external view returns (uint chipAvailable) {
return players[user].chips.length >= 200 ? 200 : players[user].chips.length;
}
function playerChipsOf(address user) public view returns (uint[] memory playerChips,
uint[] memory playerChipsTime,
uint[] memory playerBuyMask) {
require(user != address(0), "Zero address");
playerChips = players[user].chips;
playerChipsTime = players[user].buyTime;
playerBuyMask = players[user].buyMask;
return (playerChips, playerChipsTime, playerBuyMask);
}
function getPlayerChips() external view returns (uint[] memory playerChips,
uint[] memory playerChipsTime,
uint[] memory playerBuyMask) {
return playerChipsOf(msg.sender);
}
function calcNewBuyPayouts() public view returns (uint[9] memory newPayoutsPerHour) {
uint soldStep = TokenSale(saleContract).getSoldStep();
for (uint chipId = 0; chipId < 9; chipId++) {
uint initialPayout = chipPayoutPerHour[chipId];
newPayoutsPerHour[chipId] = initialPayout + initialPayout * soldStep * 5 / 100;
}
return newPayoutsPerHour;
}
function calcUserPayoutsOf(address addr) public view returns (uint[] memory payoutsPerHour) {
require(addr != address(0), "Zero address");
uint steps = TokenSale(saleContract).getSoldStep();
uint[] memory payoutsPerHour_ = new uint[](players[addr].chips.length);
for (uint i = 0; i < players[addr].chips.length && i < 200; i++) {
uint payout = calcPayout(chipPayoutPerHour[players[addr].chips[i]], players[addr].buyMask[i], steps);
payoutsPerHour_[i] = payout;
}
return payoutsPerHour_;
}
function calcPayout(uint initialPayout, uint buyMask, uint steps) public pure returns (uint payoutPerHour) {
return buyMask + initialPayout * steps / 100;
}
function calcBuyMask(uint initialPayout) public view returns (uint payoutPerHour) {
// 5% - 1%
return initialPayout + initialPayout * TokenSale(saleContract).getSoldStep() * 4 / 100;
}
function getPayoutOf(address addr) public view returns (uint) {
require(addr != address(0), "Zero address");
uint value = 0;
uint lastPayout = players[addr].lastPayout;
uint steps = TokenSale(saleContract).getSoldStep();
for (uint i = 0; i < players[addr].chips.length && i < 200; i++) {
uint buyTime = players[addr].buyTime[i];
uint timeEnd = buyTime + chipLifeDays[players[addr].chips[i]] * 86400;
uint from_ = lastPayout > buyTime ? lastPayout : buyTime;
uint to = now > timeEnd ? timeEnd : now;
uint payoutPerHour = calcPayout(chipPayoutPerHour[players[addr].chips[i]], players[addr].buyMask[i], steps);
if (from_ < to) {
//DEV SET 3600
value += ((to - from_) / 60) * payoutPerHour;
}
}
return value - reinvestMask[addr];
}
// TRX - TLT converters
function inTLT(uint amount) public view returns (uint) {
return amount / TokenSale(saleContract).getRate() * 100000;
}
function inTRX(uint amountTLT) public view returns (uint) {
return amountTLT * TokenSale(saleContract).getRate() / 100000;
}
//
function calcPrices(address player) public view returns (uint[9] memory newPrices) {
require(player != address(0), "Zero address");
for (uint chipId = 0; chipId < 9; chipId++) {
newPrices[chipId] = _calcPrice(player, chipId);
}
return newPrices;
}
function _calcPrice(address player, uint chipId) internal view returns (uint) {
uint reinvestTime = players[player].reinvestTime;
uint price = chipPrice[chipId];
if (reinvestTime > 0 && now > reinvestTime) {
if (now - reinvestTime > 21 days) {
return price - price * 30 / 100;
} else if (now - reinvestTime > 14 days) {
return price - price * 20 / 100;
} else if (now - reinvestTime > 7 days) {
return price - price * 10 / 100;
}
}
return price;
}
function getDiscountOf(address player) public view returns (uint) {
uint reinvestTime = players[player].reinvestTime;
if (reinvestTime > 0 && now > reinvestTime) {
if (now - reinvestTime > 21 days) {
return 30;
} else if (now - reinvestTime > 14 days) {
return 20;
} else if (now - reinvestTime > 7 days) {
return 10;
}
}
return 0;
}
function _buyChip(address playerAddress, uint chipId, uint price) internal {
_processTokenExchange(playerAddress, price);
_processBuyChip(playerAddress, chipId, price);
}
function _processTokenExchange(address playerAddress, uint price) internal {
Token(token).transferFrom(playerAddress, bankAddress, price);
TLTSpent += price;
TLTSpentOf[playerAddress] += price;
checkBonus(playerAddress, TLTSpentOf[playerAddress]);
}
function _processBuyChip(address playerAddress, uint chipId, uint price) internal {
Player storage player = players[playerAddress];
if (player.chips.length == 0) playersCount += 1;
player.chips.push(chipId);
player.buyTime.push(now);
player.buyMask.push(calcBuyMask(chipPayoutPerHour[chipId]));
emit BuyChip(playerAddress, chipId, price);
}
function _getPayoutToWallet(address payable sender, uint amount) internal {
sender.transfer(amount);
}
//User functions
function buyChip(uint chipId) external isHuman isEnabled {
require(chipId < 9, "Overflow");
require(players[msg.sender].chips.length + 1 <= 200, "Chips limit 200");
uint price = _calcPrice(msg.sender, chipId);
require(Token(token).allowance(msg.sender, address(this)) >= price, "Not enough TLT allowed ");
_buyChip(msg.sender, chipId, price);
}
function buyChips(uint chipId, uint amount) external isHuman isEnabled {
require(amount > 1, "Use buyChip for that transaction");
require(chipId < 9, "Overflow");
require(players[msg.sender].chips.length + amount <= 200, "Chips limit 200");
uint price = _calcPrice(msg.sender, chipId);
require(Token(token).balanceOf(msg.sender) >= price * amount, "Not enough TLT");
for (uint i = 0; i < amount; i++) {
_buyChip(msg.sender, chipId, price);
}
}
function getPayoutToWallet() external payable isHuman isEnabled {
uint amount = getPayoutOf(msg.sender);
require(amount > 0, "No payout");
players[msg.sender].lastPayout = now;
players[msg.sender].reinvestTime = 0;
reinvestMask[msg.sender] = 0;
TRXReceive += amount;
TRXReceiveOf[msg.sender] += amount;
_getPayoutToWallet(msg.sender, amount);
emit Payout(msg.sender, amount);
}
function reinvest(uint chipId) external isHuman isEnabled {
require(chipId < 9, "Overflow");
uint amount = getPayoutOf(msg.sender);
require(amount > 0, "No payout");
uint amountTLT = inTLT(amount);
uint price = _calcPrice(msg.sender, chipId);
require(amountTLT >= price && price > 0, "Too small dividends");
uint chipAmount = (amountTLT / price);
require(players[msg.sender].chips.length + chipAmount <= 200, "Chips limit 200");
uint trxVirtualSpend = inTRX(price * chipAmount);
reinvestMask[msg.sender] += trxVirtualSpend;
devWallet.transfer(trxVirtualSpend / 10); // 10% commission tokenSale
if (players[msg.sender].reinvestTime == 0) {
players[msg.sender].reinvestTime = now;
}
for(uint i=0; i < chipAmount; i++) {
_processBuyChip(msg.sender, chipId, price);
}
emit Reinvest(msg.sender, chipId, chipAmount);
}
function enableContract() external onlyOwner {
isContractEnable = true;
}
// Donations
function donate() external payable {
emit Donate(msg.sender, msg.value);
}
function() external payable {
emit Donate(msg.sender, msg.value);
}
}
| 293,902 | 30 |
10080c6bf72d6ccc01fb63c436b2c82031ecfce31acb913d69533fc68a6574c4
| 19,614 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/unchecked_low_level_calls/clean_95_buggy_curated_0/0x341ffd5852614e6a9189dc2931cb7ec3f10605b0.sol
| 4,427 | 17,834 |
pragma solidity ^0.5.0;
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;
}
}
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 CommunityVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 90 days;
uint256 constant public Interval = 90 days;
uint256 constant public MaximumHoldingPeriod = 360 days;
uint256 constant public CommunityCap = 14300000 ether; // 14.3 million tokens
uint256 public totalCommunityTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event CommunityVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event CommunityVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 90 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25); // 25% to be released every 90 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalCommunityTokensCommitted = totalCommunityTokensCommitted.add(_tokens);
require(totalCommunityTokensCommitted <= CommunityCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit CommunityVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit CommunityVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
contract EcosystemVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public Interval = 90 days;
uint256 constant public MaximumHoldingPeriod = 630 days;
uint256 constant public EcosystemCap = 54100000 ether; // 54.1 million tokens
uint256 public totalEcosystemTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event EcosystemVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event EcosystemVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 permill = calculatePermillToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(1000 - permill)).div(1000);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePermillToRelease(uint256 _startTime) internal view returns (uint256 permill) {
// how many 90 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval)).add(1);
permill = periodsPassed.mul(125); // 125 per thousand to be released every 90 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalEcosystemTokensCommitted = totalEcosystemTokensCommitted.add(_tokens);
require(totalEcosystemTokensCommitted <= EcosystemCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit EcosystemVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit EcosystemVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
contract SeedPrivateAdvisorVesting is Ownable {
using SafeMath for uint256;
enum User { Public, Seed, Private, Advisor }
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 90 days;
uint256 constant public Interval = 30 days;
uint256 constant public MaximumHoldingPeriod = 180 days;
uint256 constant public SeedCap = 28000000 ether; // 28 million tokens
uint256 constant public PrivateCap = 9000000 ether; // 9 million tokens
uint256 constant public AdvisorCap = 7400000 ether; // 7.4 million tokens
uint256 public totalSeedTokensCommitted;
uint256 public totalPrivateTokensCommitted;
uint256 public totalAdvisorTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
User user;
}
event VestingInitialized(address _to, uint256 _tokens, uint256 _startTime, User user);
event VestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime, User user);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 30 day periods have passed
uint periodsPassed = ((now.sub(_startTime.add(MinimumHoldingPeriod))).div(Interval)).add(1);
percentage = periodsPassed.mul(25); // 25% to be released every 30 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime,
uint8 user)
external
onlyOwner
{
User _user;
if (user == uint8(User.Seed)) {
_user = User.Seed;
totalSeedTokensCommitted = totalSeedTokensCommitted.add(_tokens);
require(totalSeedTokensCommitted <= SeedCap);
} else if (user == uint8(User.Private)) {
_user = User.Private;
totalPrivateTokensCommitted = totalPrivateTokensCommitted.add(_tokens);
require(totalPrivateTokensCommitted <= PrivateCap);
} else if (user == uint8(User.Advisor)) {
_user = User.Advisor;
totalAdvisorTokensCommitted = totalAdvisorTokensCommitted.add(_tokens);
require(totalAdvisorTokensCommitted <= AdvisorCap);
} else {
revert("incorrect category, not eligible for vesting");
}
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit VestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime,
holdings[_beneficiary].user);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime,
_user);
emit VestingInitialized(_beneficiary, _tokens, _startTime, _user);
}
}
}
contract TeamVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 180 days;
uint256 constant public Interval = 180 days;
uint256 constant public MaximumHoldingPeriod = 720 days;
uint256 constant public TeamCap = 12200000 ether; // 12.2 million tokens
uint256 public totalTeamTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event TeamVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event TeamVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 180 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25); // 25% to be released every 180 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalTeamTokensCommitted = totalTeamTokensCommitted.add(_tokens);
require(totalTeamTokensCommitted <= TeamCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit TeamVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit TeamVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
interface TokenInterface {
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Vesting is Ownable {
using SafeMath for uint256;
enum VestingUser { Public, Seed, Private, Advisor, Team, Community, Ecosystem }
TokenInterface public token;
CommunityVesting public communityVesting;
TeamVesting public teamVesting;
EcosystemVesting public ecosystemVesting;
SeedPrivateAdvisorVesting public seedPrivateAdvisorVesting;
mapping (address => VestingUser) public userCategory;
uint256 public totalAllocated;
event TokensReleased(address _to, uint256 _tokensReleased, VestingUser user);
constructor(address _token) public {
//require(_token != 0x0, "Invalid address");
token = TokenInterface(_token);
communityVesting = new CommunityVesting();
teamVesting = new TeamVesting();
ecosystemVesting = new EcosystemVesting();
seedPrivateAdvisorVesting = new SeedPrivateAdvisorVesting();
}
function claimTokens() external {
uint8 category = uint8(userCategory[msg.sender]);
uint256 tokensToClaim;
if (category == 1 || category == 2 || category == 3) {
tokensToClaim = seedPrivateAdvisorVesting.claimTokens(msg.sender);
} else if (category == 4) {
tokensToClaim = teamVesting.claimTokens(msg.sender);
} else if (category == 5) {
tokensToClaim = communityVesting.claimTokens(msg.sender);
} else if (category == 6){
tokensToClaim = ecosystemVesting.claimTokens(msg.sender);
} else {
revert("incorrect category, maybe unknown user");
}
totalAllocated = totalAllocated.sub(tokensToClaim);
require(token.transfer(msg.sender, tokensToClaim), "Insufficient balance in vesting contract");
emit TokensReleased(msg.sender, tokensToClaim, userCategory[msg.sender]);
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime,
VestingUser user)
external
onlyOwner
{
uint8 category = uint8(user);
require(category != 0, "Not eligible for vesting");
require(uint8(userCategory[_beneficiary]) == 0 || userCategory[_beneficiary] == user, "cannot change user category");
userCategory[_beneficiary] = user;
totalAllocated = totalAllocated.add(_tokens);
if (category == 1 || category == 2 || category == 3) {
seedPrivateAdvisorVesting.initializeVesting(_beneficiary, _tokens, _startTime, category);
} else if (category == 4) {
teamVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else if (category == 5) {
communityVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else if (category == 6){
ecosystemVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else {
revert("incorrect category, not eligible for vesting");
}
}
function claimUnallocated(address _sendTo) external onlyOwner{
uint256 allTokens = token.balanceOf(address(this));
token.transfer(_sendTo, allTokens);
}
}
| 132,625 | 31 |
fa362597d70fb05c56134f9685e32e79f748d74c83c0380ba8c0477d2917c55d
| 27,574 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4e/4ecfe3724ba29e9ebce0d3806d206e7f9c7ba218_SeedDistribution.sol
| 3,200 | 12,851 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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");
}
}
}
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);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract SeedDistribution is Ownable {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
event RewardClaimed(address indexed user, uint256 amount);
address public immutable HeC;
uint256 public immutable epochLength;
mapping(address => uint) public walletIndex;
struct Info {
uint256 rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
uint256 debt;
uint256 lastEpochTime;
}
Info[] public info;
constructor(address _hec, uint256 _epochLength) {
require(_hec != address(0));
HeC = _hec;
epochLength = _epochLength;
}
function claim() external {
uint index = walletIndex[msg.sender];
require(info[ index ].recipient == msg.sender, "Not in whitelist");
uint256 waitingEpochTime = info[ index ].lastEpochTime;
require(waitingEpochTime <= uint256(block.timestamp), "Cliff not finished.");
uint256 dayDiff = (uint256(block.timestamp) - waitingEpochTime).div(epochLength);
require(info[ index ].debt > 0, "All debts have been claimed");
require(dayDiff > 0, "Reward not ready");
// distribute rewards to sender
uint256 valueToSend = info[ index ].rate.mul(dayDiff);
if(valueToSend > info[ index ].debt) {
valueToSend = info[ index ].debt;
}
info[ index ].debt = info[ index ].debt.sub(valueToSend);
info[ index ].lastEpochTime = waitingEpochTime.add(epochLength.mul(dayDiff));
IERC20(HeC).safeTransfer(msg.sender, valueToSend);
emit RewardClaimed(msg.sender, valueToSend);
}
function addRecipient(address _recipient, uint256 _rewardRate, uint256 _debt, uint256 _lastEpochTime) external onlyOwner() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate,
debt: _debt,
lastEpochTime: _lastEpochTime
}));
walletIndex[_recipient] = info.length - 1;
}
function removeRecipient(uint _index, address _recipient) external onlyOwner() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
info[ _index ].lastEpochTime = 0;
}
function withdraw() external onlyOwner(){
uint256 total = IERC20(HeC).balanceOf(address(this));
IERC20(HeC).safeTransfer(msg.sender, total);
}
}
| 98,157 | 32 |
b465f8e39bee492e605d24b9f596da11de47f6920c2ba6d6edfe8660c780c56d
| 16,612 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2aec18c5500f21359ce1bea5dc1777344df4c0dc.sol
| 3,208 | 11,454 |
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 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 Ownable {
address public owner;
modifier onlyOwner {
require(isOwner(msg.sender));
_;
}
function Ownable() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function isOwner(address _address) public constant returns (bool) {
return owner == _address;
}
}
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 TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
contract FTT is Ownable {
using SafeMath for uint256;
uint256 public totalSupply = 1000000000 * 10**uint256(decimals);
string public constant name = "FarmaTrust Token";
string public symbol = "FTT";
uint8 public constant decimals = 18;
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event FTTIssued(address indexed from, address indexed to, uint256 indexed amount, uint256 timestamp);
event TdeStarted(uint256 startTime);
event TdeStopped(uint256 stopTime);
event TdeFinalized(uint256 finalizeTime);
// Amount of FTT available during tok0x2Ec9F52A5e4E7B5e20C031C1870Fd952e1F01b3Een distribution event.
uint256 public constant FT_TOKEN_SALE_CAP = 600000000 * 10**uint256(decimals);
// Amount held for operational usage.
uint256 public FT_OPERATIONAL_FUND = totalSupply - FT_TOKEN_SALE_CAP;
// Amount held for team usage.
uint256 public FT_TEAM_FUND = FT_OPERATIONAL_FUND / 10;
// Amount of FTT issued.
uint256 public fttIssued = 0;
address public tdeIssuer = 0x2Ec9F52A5e4E7B5e20C031C1870Fd952e1F01b3E;
address public teamVestingAddress;
address public unsoldVestingAddress;
address public operationalReserveAddress;
bool public tdeActive;
bool public tdeStarted;
bool public isFinalized = false;
bool public capReached;
uint256 public tdeDuration = 60 days;
uint256 public tdeStartTime;
function FTT() public {
}
modifier onlyTdeIssuer {
require(msg.sender == tdeIssuer);
_;
}
modifier tdeRunning {
require(tdeActive && block.timestamp < tdeStartTime + tdeDuration);
_;
}
modifier tdeEnded {
require(((!tdeActive && block.timestamp > tdeStartTime + tdeDuration) && tdeStarted) || capReached);
_;
}
function startTde()
public
onlyOwner
{
require(!isFinalized);
tdeActive = true;
tdeStarted = true;
if (tdeStartTime == 0) {
tdeStartTime = block.timestamp;
}
TdeStarted(tdeStartTime);
}
function stopTde(bool _restart)
external
onlyOwner
{
tdeActive = false;
if (_restart) {
tdeStartTime = 0;
}
TdeStopped(block.timestamp);
}
function extendTde(uint256 _time)
external
onlyOwner
{
tdeDuration = tdeDuration.add(_time);
}
function shortenTde(uint256 _time)
external
onlyOwner
{
tdeDuration = tdeDuration.sub(_time);
}
function setTdeIssuer(address _tdeIssuer)
external
onlyOwner
{
tdeIssuer = _tdeIssuer;
}
function setOperationalReserveAddress(address _operationalReserveAddress)
external
onlyOwner
tdeRunning
{
operationalReserveAddress = _operationalReserveAddress;
}
function issueFTT(address _user, uint256 _fttAmount)
public
onlyTdeIssuer
tdeRunning
returns(bool)
{
uint256 newAmountIssued = fttIssued.add(_fttAmount);
require(_user != address(0));
require(_fttAmount > 0);
require(newAmountIssued <= FT_TOKEN_SALE_CAP);
balances[_user] = balances[_user].add(_fttAmount);
fttIssued = newAmountIssued;
FTTIssued(tdeIssuer, _user, _fttAmount, block.timestamp);
if (fttIssued == FT_TOKEN_SALE_CAP) {
capReached = true;
}
return true;
}
function fttIssued()
external
view
returns (uint256)
{
return fttIssued;
}
function finalize()
external
tdeEnded
onlyOwner
{
require(!isFinalized);
// Deposit team fund amount into team vesting contract.
uint256 teamVestingCliff = 15778476; // 6 months
uint256 teamVestingDuration = 1 years;
TokenVesting teamVesting = new TokenVesting(owner, now, teamVestingCliff, teamVestingDuration, true);
teamVesting.transferOwnership(owner);
teamVestingAddress = address(teamVesting);
balances[teamVestingAddress] = FT_TEAM_FUND;
if (!capReached) {
// Deposit unsold FTT into unsold vesting contract.
uint256 unsoldVestingCliff = 3 years;
uint256 unsoldVestingDuration = 10 years;
TokenVesting unsoldVesting = new TokenVesting(owner, now, unsoldVestingCliff, unsoldVestingDuration, true);
unsoldVesting.transferOwnership(owner);
unsoldVestingAddress = address(unsoldVesting);
balances[unsoldVestingAddress] = FT_TOKEN_SALE_CAP - fttIssued;
}
// Allocate operational reserve of FTT.
balances[operationalReserveAddress] = FT_OPERATIONAL_FUND - FT_TEAM_FUND;
isFinalized = true;
TdeFinalized(block.timestamp);
}
function transferFrom(address _from, address _to, uint256 _value)
public
returns (bool)
{
if (!isFinalized) return false;
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 transfer(address _to, uint256 _value)
public
returns (bool)
{
if (!isFinalized) return false;
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value)
public
returns (bool)
{
require(_spender != address(0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function balanceOf(address _owner)
public
view
returns (uint256 balance)
{
return balances[_owner];
}
function allowance(address _owner, address _spender)
public
view
returns (uint256)
{
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;
}
}
| 215,978 | 33 |
263aabea62d2e8358f9a3551bfa2434a54ee7fbd97a1615e18b39acebc292fa2
| 30,412 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x422e8E504f8f29029D85184011e00a7126981E5D/contract.sol
| 5,207 | 18,526 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AvoYield is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'AvoYield.finance';
string private constant _SYMBOL = 'AVO';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 1000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private _TAX_FEE = 0;
uint256 private _BURN_FEE = 0;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 50 && taxFee <= 1000, 'taxFee should be in 1 - 10');
_TAX_FEE = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 50 && burnFee <= 1000, 'burnFee should be in 1 - 10');
_BURN_FEE = burnFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 256,739 | 34 |
60a987d57d00a9473109a7f3cffbf24443ad2c0183c3ff4a12d9fbe230c1cb31
| 27,434 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/02/029F209249875f8C4CcE1C8c1980bf7eDBA523F4_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 78,149 | 35 |
d9aeebe8e2bf96cf94593155b608e86e4b92ff8111647984c1c2b29123e385dc
| 19,638 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCrYVchgvCX2mE71CgYdbFUxU85DbPuJt7_Router.sol
| 5,587 | 19,013 |
//SourceUnit: Router.sol
pragma solidity 0.5.12;
interface ITRC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint8);
function totalSupply() external view returns(uint256);
function balanceOf(address owner) external view returns(uint256);
function allowance(address owner, address spender) external view returns(uint256);
}
interface IFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256 index);
function createPair(address tokenA, address tokenB) external returns(address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function feeTo() external view returns(address);
function feeToSetter() external view returns(address);
function getPair(address tokenA, address tokenB) external view returns(address pair);
function allPairs(uint256) external view returns(address pair);
function allPairsLength() external view returns(uint256);
}
interface IPair {
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function mint(address to) external returns(uint256 liquidity);
function burn(address to) external returns(uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
function MINIMUM_LIQUIDITY() external pure returns(uint256);
function factory() external view returns(address);
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns(uint256);
function price1CumulativeLast() external view returns(uint256);
function kLast() external view returns(uint256);
}
interface IWTRX {
function deposit() external payable;
function withdraw(uint256) external;
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint256 x, uint256 y) internal pure returns(uint256 z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library TransferHelper {
function safeTransfer(address token, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (token == 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C || data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint256 value) internal {
(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 safeTransferTRX(address to, uint256 value) internal {
(bool success,) = to.call.value(value)(new bytes(0));
require(success, 'TransferHelper: TRX_TRANSFER_FAILED');
}
}
library SwapLibrary {
using SafeMath for uint256;
function sortTokens(address tokenA, address tokenB) internal pure returns(address token0, address token1) {
require(tokenA != tokenB, 'SwapLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'SwapLibrary: ZERO_ADDRESS');
}
function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) internal pure returns(uint256 amountB) {
require(amountA > 0, 'SwapLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal pure returns(uint256 amountOut) {
require(amountIn > 0, 'SwapLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
uint256 amountInWithFee = amountIn.mul(997);
amountOut = amountInWithFee.mul(reserveOut) / reserveIn.mul(1000).add(amountInWithFee);
}
function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) internal pure returns(uint256 amountIn) {
require(amountOut > 0, 'SwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
amountIn = (reserveIn.mul(amountOut).mul(1000) / reserveOut.sub(amountOut).mul(997)).add(1);
}
function pairFor(address factory, address tokenA, address tokenB) internal view returns(address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = IFactory(factory).getPair(token0, token1);
require(pair != address(0), "SwapLibrary: UNDEFINED_PAIR");
}
function getReserves(address factory, address tokenA, address tokenB) internal view returns(uint256 reserveA, uint256 reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint256 reserve0, uint256 reserve1,) = IPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
function getAmountsOut(address factory, uint256 amountIn, address[] memory path) internal view returns(uint256[] memory amounts) {
require(path.length >= 2, 'SwapLibrary: INVALID_PATH');
amounts = new uint256[](path.length);
amounts[0] = amountIn;
for(uint256 i; i < path.length - 1; i++) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountsIn(address factory, uint256 amountOut, address[] memory path) internal view returns(uint256[] memory amounts) {
require(path.length >= 2, 'SwapLibrary: INVALID_PATH');
amounts = new uint256[](path.length);
amounts[amounts.length - 1] = amountOut;
for(uint256 i = path.length - 1; i > 0; i--) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
contract Router {
using SafeMath for uint256;
address public factory;
address public wtrx;
modifier ensure(uint256 deadline) {
require(deadline >= block.timestamp, 'Router: EXPIRED');
_;
}
constructor(address _factory, address _wtrx) public {
factory = _factory;
wtrx = _wtrx;
}
function() payable external {
assert(msg.sender == wtrx);
}
function _addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin) internal returns(uint256 amountA, uint256 amountB) {
if(IFactory(factory).getPair(tokenA, tokenB) == address(0)) {
IFactory(factory).createPair(tokenA, tokenB);
}
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
if(reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
}
else {
uint256 amountBOptimal = SwapLibrary.quote(amountADesired, reserveA, reserveB);
if(amountBOptimal <= amountBDesired) {
require(amountBOptimal >= amountBMin, 'Router: INSUFFICIENT_B_AMOUNT');
(amountA, amountB) = (amountADesired, amountBOptimal);
}
else {
uint256 amountAOptimal = SwapLibrary.quote(amountBDesired, reserveB, reserveA);
assert(amountAOptimal <= amountADesired);
require(amountAOptimal >= amountAMin, 'Router: INSUFFICIENT_A_AMOUNT');
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
function _swap(uint256[] memory amounts, address[] memory path, address _to) internal {
for(uint256 i; i < path.length - 1; i++) {
(address input, address output) = (path[i], path[i + 1]);
(address token0,) = SwapLibrary.sortTokens(input, output);
uint256 amountOut = amounts[i + 1];
(uint256 amount0Out, uint256 amount1Out) = input == token0 ? (uint256(0), amountOut) : (amountOut, uint256(0));
address to = i < path.length - 2 ? SwapLibrary.pairFor(factory, output, path[i + 2]) : _to;
IPair(SwapLibrary.pairFor(factory, input, output)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external ensure(deadline) returns(uint256 amountA, uint256 amountB, uint256 liquidity) {
(amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
address pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
liquidity = IPair(pair).mint(to);
}
function addLiquidityTRX(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountTRXMin, address to, uint256 deadline) external payable ensure(deadline) returns(uint256 amountToken, uint256 amountTRX, uint256 liquidity) {
(amountToken, amountTRX) = _addLiquidity(token, wtrx, amountTokenDesired, msg.value, amountTokenMin, amountTRXMin);
address pair = SwapLibrary.pairFor(factory, token, wtrx);
TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
IWTRX(wtrx).deposit.value(amountTRX)();
assert(ITRC20(wtrx).transfer(pair, amountTRX));
liquidity = IPair(pair).mint(to);
if(msg.value > amountTRX) TransferHelper.safeTransferTRX(msg.sender, msg.value - amountTRX);
}
function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) public ensure(deadline) returns(uint256 amountA, uint256 amountB) {
address pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
ITRC20(pair).transferFrom(msg.sender, pair, liquidity);
(uint256 amount0, uint256 amount1) = IPair(pair).burn(to);
(address token0,) = SwapLibrary.sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'Router: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'Router: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityTRX(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountTRXMin, address to, uint256 deadline) public ensure(deadline) returns(uint256 amountToken, uint256 amountTRX) {
(amountToken, amountTRX) = removeLiquidity(token, wtrx, liquidity, amountTokenMin, amountTRXMin, address(this), deadline);
TransferHelper.safeTransfer(token, to, amountToken);
IWTRX(wtrx).withdraw(amountTRX);
TransferHelper.safeTransferTRX(to, amountTRX);
}
function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
amounts = SwapLibrary.getAmountsOut(factory, amountIn, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, to);
}
function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= amountInMax, 'Router: EXCESSIVE_INPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, to);
}
function swapExactTRXForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable ensure(deadline) returns(uint256[] memory amounts) {
require(path[0] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsOut(factory, msg.value, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
IWTRX(wtrx).deposit.value(amounts[0])();
assert(ITRC20(wtrx).transfer(SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
_swap(amounts, path, to);
}
function swapTRXForExactTokens(uint256 amountOut, address[] calldata path, address to, uint256 deadline) external payable ensure(deadline) returns(uint256[] memory amounts) {
require(path[0] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= msg.value, 'Router: EXCESSIVE_INPUT_AMOUNT');
IWTRX(wtrx).deposit.value(amounts[0])();
assert(ITRC20(wtrx).transfer(SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
_swap(amounts, path, to);
if(msg.value > amounts[0]) TransferHelper.safeTransferTRX(msg.sender, msg.value - amounts[0]);
}
function swapExactTokensForTRX(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
require(path[path.length - 1] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsOut(factory, amountIn, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, address(this));
IWTRX(wtrx).withdraw(amounts[amounts.length - 1]);
TransferHelper.safeTransferTRX(to, amounts[amounts.length - 1]);
}
function swapTokensForExactTRX(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
require(path[path.length - 1] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= amountInMax, 'Router: EXCESSIVE_INPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, address(this));
IWTRX(wtrx).withdraw(amounts[amounts.length - 1]);
TransferHelper.safeTransferTRX(to, amounts[amounts.length - 1]);
}
function getAmountsIn(uint256 amountOut, address[] memory path) public view returns (uint256[] memory amounts) {
return SwapLibrary.getAmountsIn(factory, amountOut, path);
}
function getAmountsOut(uint256 amountIn, address[] memory path) public view returns(uint256[] memory amounts) {
return SwapLibrary.getAmountsOut(factory, amountIn, path);
}
function calcPairLiquidity(uint256 amountA, address tokenA, address tokenB, bool reverse) external view returns(uint256 amountB, uint256 share) {
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
amountB = reverse ? SwapLibrary.quote(amountA, reserveB, reserveA) : SwapLibrary.quote(amountA, reserveA, reserveB);
share = reverse ? amountA.mul(100) / reserveB.add(amountA) : amountA.mul(100) / reserveA.add(amountA);
}
function calcPairSwap(uint256 amountA, address tokenA, address tokenB, bool reverse) external view returns(uint256 amountB, uint256 priceImpact) {
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
amountB = reverse ? SwapLibrary.getAmountIn(amountA, reserveA, reserveB) : SwapLibrary.getAmountOut(amountA, reserveA, reserveB);
priceImpact = reverse ? reserveA.sub(reserveA.sub(amountB)).mul(10000) / reserveA : reserveB.sub(reserveB.sub(amountB)).mul(10000) / reserveB;
}
function getPair(address owner, address tokenA, address tokenB) external view returns(address pair, uint256 totalSupply, uint256 supply, uint256 reserveA, uint256 reserveB) {
pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
totalSupply = ITRC20(pair).totalSupply();
supply = ITRC20(pair).balanceOf(owner);
(address token0,) = SwapLibrary.sortTokens(tokenA, tokenB);
if(token0 != tokenA) (reserveB, reserveA) = SwapLibrary.getReserves(factory, tokenA, tokenB);
else (reserveA, reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
}
function getPairs(address owner, uint256 start, uint256 limit) external view returns(uint256 count, address[] memory from, address[] memory to, uint256[] memory supply) {
count = IFactory(factory).allPairsLength();
from = new address[](limit);
to = new address[](limit);
supply = new uint256[](limit);
uint256 matches = 0;
for(uint256 i = start; i < start + limit && i < count; i++) {
address pair = IFactory(factory).allPairs(i);
from[matches] = IPair(pair).token0();
to[matches] = IPair(pair).token1();
supply[matches++] = ITRC20(pair).balanceOf(owner);
}
}
}
| 303,915 | 36 |
cbb84e5878ef746e8834d81b3721b7a43a671b9570fe20485cf1eed9fc356430
| 20,826 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc0e6c996f3642c3ff3287ef01375fa7b72702797.sol
| 4,905 | 18,919 |
pragma solidity ^0.4.19;
contract BitOpterations {
// helper functions set
// to manipulate on bits
// with different widht of allocator
function set512(bytes32[2] storage allocator,uint16 pos,uint8 value) internal returns(bytes32[2] storage) {
bytes32 valueBits = (bytes32)(value);
uint8 posOffset = uint8(pos%255);
bytes32 one = 1;
bytes32 clearBit = (bytes32)(~(one << posOffset));
uint8 bytesIndex = pos>255?1:0;
allocator[bytesIndex] = (allocator[bytesIndex] & clearBit) | (valueBits << posOffset);
return allocator;
}
function get512(bytes32[2] allocator,uint16 pos) internal pure returns(uint8){
uint8 posOffset = uint8(pos%255);
uint8 bytesIndex = pos>255?1:0;
return (((allocator[bytesIndex] >> posOffset) & 1) == 1)?1:0;
}
function clear512(bytes32[2] storage allocator) internal {
allocator[0] = 0x0;
allocator[1] = 0x0;
}
function set32(bytes4 allocator,uint8 pos, uint8 value) internal pure returns(bytes4) {
bytes4 valueBits = (bytes4)(value);
bytes4 one = 1;
bytes4 clearBit = (bytes4)(~(one << pos));
allocator = (allocator & clearBit) | (valueBits << pos);
return allocator;
}
function get32(bytes4 allocator,uint8 pos) internal pure returns(uint8){
return (((allocator >> pos) & 1) == 1)?1:0;
}
}
contract Random32BigInteger is BitOpterations {
uint256[10] public randomBlockStart;
bytes4[10] private numberAllocator;
bool[10] internal generated;
uint256 private generationNumber = 0;
function generate(uint8 lotteryId) internal returns(bool) {
// to eliminate problem of `same random numbers` lets add
// some offset on each number generation
uint8 startOffset = uint8((generationNumber++) % 10);
if (randomBlockStart[lotteryId] == 0) {
// start random number generation from next block,
// so we can't influence it
randomBlockStart[lotteryId] = block.number + startOffset;
} else {
uint256 blockDiffNumber = block.number - randomBlockStart[lotteryId];
// revert tx if we haven't enough blocks to calc rand int
require(blockDiffNumber >= 32);
// its not possible to calc fair random number with start at randomBlockStart
// because part of blocks or all blocks are not visible from solidity anymore
// start generation process one more time
if (blockDiffNumber > 256) {
randomBlockStart[lotteryId] = block.number + startOffset;
} else {
for (uint8 i = 0; i < 32; i++) {
// get hash of appropriate block
uint256 blockHash = uint256(block.blockhash(randomBlockStart[lotteryId]+i));
// set appropriate bit in result number
numberAllocator[lotteryId] = set32(numberAllocator[lotteryId],i,uint8(blockHash));
}
generated[lotteryId] = true;
randomBlockStart[lotteryId] = 0;
}
}
return generated[lotteryId];
}
function clearNumber(uint8 lotteryId) internal {
randomBlockStart[lotteryId] = 0;
generated[lotteryId] = false;
}
function getNumberValue(uint8 lotteryId) internal constant returns(uint32) {
require(generated[lotteryId]);
return uint32(numberAllocator[lotteryId]);
}
}
contract EthereumJackpot is Random32BigInteger {
address private owner;
event WinnerPicked(uint8 indexed roomId,address winner,uint16 number);
event TicketsBought(uint8 indexed roomId,address owner,uint16[] ticketNumbers);
event LostPayment(address dest,uint256 amount);
struct Winner {
uint256 prize;
uint256 timestamp;
address addr;
uint16 number;
uint8 percent;
}
mapping (address => address) public affiliates;
Winner[] private winners;
uint32 public winnersCount;
modifier ownerOnly {
require(msg.sender == owner);
_;
}
uint8 public affiliatePercent = 1;
uint8 public maxPercentPerPlayer = 49;
uint8 public ownerComission = 20;
// time on which lottery has started
uint256[10] public started;
// last activity time on lottery
uint256[10] public lastTicketBought;
// one ticket price
uint256[10] public ticketPrice;
// max number of tickets in this lottery
uint16[10] public maxTickets;
// time to live before refund can be requested
uint256[10] public lifetime;
address[][10] ticketsAllocator;
struct Player {
uint256 changedOn;
uint16 ticketsCount;
}
mapping(address => Player)[10] private playerInfoMappings;
bytes32[2][10] bitMaskForPlayFields;
enum State {Uninitialized,Running,Paused,Finished,Refund}
State[10] public state;
// flag that indicates request for pause of lottery[id]
bool[10] private requestPause;
// number of sold tickets
uint16[10] public ticketsSold;
// this function set flag to pause room on next clearState call (at the game start)
function pauseLottery(uint8 lotteryId) public ownerOnly {
requestPause[lotteryId] = true;
}
function setOwner(address newOwner) public ownerOnly {
owner = newOwner;
}
function getTickets(uint8 lotteryId) public view returns(uint8[]) {
uint8[] memory result = new uint8[](maxTickets[lotteryId]);
for (uint16 i = 0; i < maxTickets[lotteryId]; i++) {
result[i] = get512(bitMaskForPlayFields[lotteryId],i);
}
return result;
}
function setLotteryOptions(uint8 lotteryId,uint256 price,uint16 tickets,uint256 timeToRefund) public ownerOnly {
require(lotteryId >= 0 && lotteryId < 10);
require(state[lotteryId] == State.Paused || state[lotteryId] == State.Uninitialized || ticketsSold[lotteryId] == 0);
require(price > 0);
require(tickets > 0 && tickets <= 500);
require(timeToRefund >= 86400); // require at least one day to sell all tickets
ticketPrice[lotteryId] = price;
maxTickets[lotteryId] = tickets;
lifetime[lotteryId] = timeToRefund;
ticketsAllocator[lotteryId].length = tickets;
clearState(lotteryId);
}
// this methods clears the state
// of current lottery
function clearState(uint8 lotteryId) private {
if (!requestPause[lotteryId]) {
// set state of lottery to `running`
state[lotteryId] = State.Running;
// clear random number data
clearNumber(lotteryId);
// set current timestamp as start time
started[lotteryId] = block.timestamp;
// clear time of last ticket bought
lastTicketBought[lotteryId] = 0;
// clear number of sold tickets
ticketsSold[lotteryId] = 0;
// remove previous tickets owner info
clear512(bitMaskForPlayFields[lotteryId]);
} else {
// set state to `pause`
state[lotteryId] = State.Paused;
requestPause[lotteryId] = false;
}
}
function isInList(address element,address[] memory list) private pure returns (bool) {
for (uint16 i =0; i < list.length; i++) {
if (list[i] == element) {
return true;
}
}
return false;
}
function getPlayers(uint8 lotteryId) external view returns (uint16,address[],uint16[]) {
if (ticketsSold[lotteryId] == 0) {
return;
}
uint16 currentUser = 0;
address[] memory resultAddr = new address[](maxTickets[lotteryId]);
uint16[] memory resultCount = new uint16[](maxTickets[lotteryId]);
for (uint16 t = 0; t < maxTickets[lotteryId]; t++) {
uint8 ticketBoughtHere = get512(bitMaskForPlayFields[lotteryId],t);
if (ticketBoughtHere != 0) {
address currentAddr = ticketsAllocator[lotteryId][t];
if (!isInList(currentAddr,resultAddr)) {
Player storage pInfo = playerInfoMappings[lotteryId][currentAddr];
resultAddr[currentUser] = currentAddr;
resultCount[currentUser] = pInfo.ticketsCount;
++currentUser;
}
}
}
return (currentUser,resultAddr,resultCount);
}
// in case lottery tickets weren't sold due some time
// anybody who bought a ticket can
// ask to refund money (- comission to send them)
// function refund(uint8 lotteryId) public {
// // refund state could be reached only from `running` state
// require (state[lotteryId] == State.Running);
// require (block.timestamp > (started[lotteryId] + lifetime[lotteryId]));
// require (ticketsSold[lotteryId] < maxTickets[lotteryId]);
// // check if its a person which plays this lottery
// // or it's a lottery owner
// uint256 notSend = 0;
// // disallow re-entrancy
// // refund process
// state[lotteryId] = State.Refund;
// for (uint16 i = 0; i < maxTickets[lotteryId]; i++) {
// address tOwner = ticketsAllocator[lotteryId][i];
// if (tOwner != address(0)) {
// bool sendResult = tOwner.send(value);
// if (!sendResult) {
// LostPayment(tOwner,value);
// notSend += value;
// }
// }
// }
// // send rest to owner if there any
// if (notSend > 0) {
// owner.send(notSend);
// }
// // start new lottery
// clearState(lotteryId);
// }
// this method determines current game winner
function getWinner(uint8 lotteryId) private view returns(uint16,address) {
require(state[lotteryId] == State.Finished);
// apply modulo operation
// so any ticket number would be within 0 and totalTickets sold
uint16 winningTicket = uint16(getNumberValue(lotteryId)) % maxTickets[lotteryId];
return (winningTicket,ticketsAllocator[lotteryId][winningTicket]);
}
// this method is used to finalize Lottery
// it generates random number and sends prize
// it uses 32 blocks to generate pseudo random
// value to determine winner of lottery
function finalizeRoom(uint8 lotteryId) public {
// here we check for re-entrancy
require(state[lotteryId] == State.Running);
// only if all tickets are sold
if (ticketsSold[lotteryId] == maxTickets[lotteryId]) {
// if rand number is not yet generated
if (generate(lotteryId)) {
// rand number is generated
// set flag to allow getting winner
// disable re-entrancy
state[lotteryId] = State.Finished;
var (winNumber, winner) = getWinner(lotteryId);
uint256 prizeTotal = ticketsSold[lotteryId]*ticketPrice[lotteryId];
// at start, owner commision value equals to the approproate percent of the jackpot
uint256 ownerComValue = ((prizeTotal*ownerComission)/100);
// winner prize equals total jackpot sum - owner commision value in any case
uint256 prize = prizeTotal - ownerComValue;
address affiliate = affiliates[winner];
if (affiliate != address(0)) {
uint256 affiliatePrize = (prizeTotal*affiliatePercent)/100;
bool afPResult = affiliate.send(affiliatePrize);
if (!afPResult) {
LostPayment(affiliate,affiliatePrize);
} else {
// minus affiliate prize and "gas price" for that tx from owners com value
ownerComValue -= affiliatePrize;
}
}
// pay prize
bool prizeSendResult = winner.send(prize);
if (!prizeSendResult) {
LostPayment(winner,prize);
ownerComValue += prize;
}
// put winner to winners
uint8 winPercent = uint8(((playerInfoMappings[lotteryId][winner].ticketsCount*100)/maxTickets[lotteryId]));
addWinner(prize,winner,winNumber,winPercent);
WinnerPicked(lotteryId,winner,winNumber);
// send owner commision
owner.send(ownerComValue);
clearState(lotteryId);
}
}
}
function buyTicket(uint8 lotteryId,uint16[] tickets,address referer) payable public {
// we're actually in `running` state
require(state[lotteryId] == State.Running);
// not all tickets are sold yet
require(maxTickets[lotteryId] > ticketsSold[lotteryId]);
if (referer != address(0)) {
setReferer(referer);
}
uint16 ticketsToBuy = uint16(tickets.length);
// check payment for ticket
uint256 valueRequired = ticketsToBuy*ticketPrice[lotteryId];
require(valueRequired <= msg.value);
// soft check if player want to buy free tickets
require((maxTickets[lotteryId] - ticketsSold[lotteryId]) >= ticketsToBuy);
Player storage pInfo = playerInfoMappings[lotteryId][msg.sender];
if (pInfo.changedOn < started[lotteryId]) {
pInfo.changedOn = block.timestamp;
pInfo.ticketsCount = 0;
}
// check percentage of user's tickets
require ((pInfo.ticketsCount+ticketsToBuy) <= ((maxTickets[lotteryId]*maxPercentPerPlayer)/100));
for (uint16 i; i < ticketsToBuy; i++) {
require((tickets[i] - 1) >= 0);
// if the ticket is taken you would get your ethers back
require (get512(bitMaskForPlayFields[lotteryId],tickets[i]-1) == 0);
set512(bitMaskForPlayFields[lotteryId],tickets[i]-1,1);
ticketsAllocator[lotteryId][tickets[i]-1] = msg.sender;
}
pInfo.ticketsCount += ticketsToBuy;
// set last time of buy
lastTicketBought[lotteryId] = block.timestamp;
// set new amount of tickets
ticketsSold[lotteryId] += ticketsToBuy;
// start process of random number generation if last ticket was sold
if (ticketsSold[lotteryId] == maxTickets[lotteryId]) {
finalizeRoom(lotteryId);
}
// fire event
TicketsBought(lotteryId,msg.sender,tickets);
}
function roomNeedsFinalization(uint8 lotteryId) internal view returns (bool){
return (state[lotteryId] == State.Running && (ticketsSold[lotteryId] >= maxTickets[lotteryId]) && ((randomBlockStart[lotteryId] == 0) || ((randomBlockStart[lotteryId] > 0) && (block.number - randomBlockStart[lotteryId]) >= 32)));
}
function EthereumJackpot(address ownerAddress) public {
require(ownerAddress != address(0));
owner = ownerAddress;
winners.length = 5;
winnersCount = 0;
}
function addWinner(uint256 prize,address winner,uint16 number,uint8 percent) private {
// check winners size and resize it if needed
if (winners.length == winnersCount) {
winners.length += 10;
}
winners[winnersCount++] = Winner(prize,block.timestamp,winner,number,percent);
}
function setReferer(address a) private {
if (a != msg.sender) {
address addr = affiliates[msg.sender];
if (addr == address(0)) {
affiliates[msg.sender] = a;
}
}
}
// // returns only x last winners to prevent stack overflow of vm
function getWinners(uint256 page) public view returns(uint256[],address[],uint256[],uint16[],uint8[]) {
int256 start = winnersCount - int256(10*(page+1));
int256 end = start+10;
if (start < 0) {
start = 0;
}
if (end <= 0) {
return;
}
address[] memory addr = new address[](uint256(end- start));
uint256[] memory sum = new uint256[](uint256(end- start));
uint256[] memory time = new uint256[](uint256(end- start));
uint16[] memory number = new uint16[](uint256(end- start));
uint8[] memory percent = new uint8[](uint256(end- start));
for (uint256 i = uint256(start); i < uint256(end); i++) {
Winner storage winner = winners[i];
addr[i - uint256(start)] = winner.addr;
sum[i - uint256(start)] = winner.prize;
time[i - uint256(start)] = winner.timestamp;
number[i - uint256(start)] = winner.number;
percent[i - uint256(start)] = winner.percent;
}
return (sum,addr,time,number,percent);
}
function getRomms() public view returns(bool[] active,uint256[] price,uint16[] tickets,uint16[] ticketsBought,uint256[] prize,uint256[] lastActivity,uint8[] comission) {
uint8 roomsCount = 10;
price = new uint256[](roomsCount);
tickets = new uint16[](roomsCount);
lastActivity = new uint256[](roomsCount);
prize = new uint256[](roomsCount);
comission = new uint8[](roomsCount);
active = new bool[](roomsCount);
ticketsBought = new uint16[](roomsCount);
for (uint8 i = 0; i < roomsCount; i++) {
price[i] = ticketPrice[i];
ticketsBought[i] = ticketsSold[i];
tickets[i] = maxTickets[i];
prize[i] = maxTickets[i]*ticketPrice[i];
lastActivity[i] = lastTicketBought[i];
comission[i] = ownerComission;
active[i] = state[i] != State.Paused && state[i] != State.Uninitialized;
}
return (active,price,tickets,ticketsBought,prize,lastActivity,comission);
}
// this function allows to destroy current contract in case all rooms are paused or not used
function destroy() public ownerOnly {
for (uint8 i = 0; i < 10; i++) {
// paused or uninitialized
require(state[i] == State.Paused || state[i] == State.Uninitialized);
}
selfdestruct(owner);
}
// finalize methods
function needsFinalization() public view returns(bool) {
for (uint8 i = 0; i < 10; i++) {
if (roomNeedsFinalization(i)) {
return true;
}
}
return false;
}
function finalize() public {
for (uint8 i = 0; i < 10; i++) {
if (roomNeedsFinalization(i)) {
finalizeRoom(i);
}
}
}
}
| 178,100 | 37 |
d6a92d2a1d66d8c747821d0bf574171d9c77124b879aaaf85623c9268df59b0d
| 12,143 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/06/0664D43b14300921197c8CE27a949d9B439436c3_TsunamiToken.sol
| 3,064 | 11,760 |
pragma solidity ^0.4.25;
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 owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'not whitelisted');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface BEP20Basic {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is BEP20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract BEP20 is BEP20Basic {
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 BEP20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Whitelist {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyWhitelisted canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyWhitelisted canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract TsunamiToken is MintableToken {
struct Stats {
uint256 txs;
uint256 minted;
}
string public constant name = "Tsunami Token";
string public constant symbol = "TSNMI";
uint8 public constant decimals = 18;
uint256 public constant MAX_INT = 2**256 - 1;
uint256 public constant targetSupply = MAX_INT;
uint256 public totalTxs;
uint256 public players;
uint256 private mintedSupply_;
mapping(address => Stats) private stats;
address public vaultAddress;
uint8 constant internal taxDefault = 10;
mapping (address => uint8) private _customTaxRate;
mapping (address => bool) private _hasCustomTax;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
event TaxPayed(address from, address vault, uint256 amount);
constructor(uint256 _initialMint) Ownable() public {
addAddressToWhitelist(owner);
mint(owner, _initialMint * 1e18);
removeAddressFromWhitelist(owner);
}
function setVaultAddress(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
}
function mint(address _to, uint256 _amount) public returns (bool) {
if (_amount == 0 || mintedSupply_.add(_amount) > targetSupply) {
return false;
}
super.mint(_to, _amount);
mintedSupply_ = mintedSupply_.add(_amount);
if (mintedSupply_ == targetSupply) {
mintingFinished = true;
emit MintFinished();
}
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_to].minted += _amount;
totalTxs += 1;
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
return false;
}
function calculateTransactionTax(uint256 _value, uint8 _tax) internal returns (uint256 adjustedValue, uint256 taxAmount){
taxAmount = _value.mul(_tax).div(100);
adjustedValue = _value.mul(SafeMath.sub(100, _tax)).div(100);
return (adjustedValue, taxAmount);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(_from, _value);
if (taxAmount > 0){
require(super.transferFrom(_from, vaultAddress, taxAmount));
emit TaxPayed(_from, vaultAddress, taxAmount);
}
require(super.transferFrom(_from, _to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_from].txs += 1;
totalTxs += 1;
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(msg.sender, _value);
if (taxAmount > 0){
require(super.transfer(vaultAddress, taxAmount));
emit TaxPayed(msg.sender, vaultAddress, taxAmount);
}
require(super.transfer(_to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[msg.sender].txs += 1;
totalTxs += 1;
return true;
}
function calculateTransferTaxes(address _from, uint256 _value) public view returns (uint256 adjustedValue, uint256 taxAmount){
adjustedValue = _value;
taxAmount = 0;
if (!_isExcluded[_from]) {
uint8 taxPercent = taxDefault;
if (_hasCustomTax[_from]){
taxPercent = _customTaxRate[_from];
}
(adjustedValue, taxAmount) = calculateTransactionTax(_value, taxPercent);
}
return (adjustedValue, taxAmount);
}
function remainingMintableSupply() public view returns (uint256) {
return targetSupply.sub(mintedSupply_);
}
function cap() public view returns (uint256) {
return targetSupply;
}
function mintedSupply() public view returns (uint256) {
return mintedSupply_;
}
function statsOf(address player) public view returns (uint256, uint256, uint256){
return (balanceOf(player), stats[player].txs, stats[player].minted);
}
function mintedBy(address player) public view returns (uint256){
return stats[player].minted;
}
function setAccountCustomTax(address account, uint8 taxRate) external onlyOwner() {
require(taxRate >= 0 && taxRate <= 100, "Invalid tax amount");
_hasCustomTax[account] = true;
_customTaxRate[account] = taxRate;
}
function removeAccountCustomTax(address account) external onlyOwner() {
_hasCustomTax[account] = false;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
_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];
_isExcluded[account] = false;
delete _excluded[_excluded.length - 1];
break;
}
}
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
}
| 130,957 | 38 |
94b591e2853264a84a0291ca2ecb882220c4f087d89085414fd07780f3da52a0
| 15,873 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x36a84dd5c8a606f44dc504aa3859b097083d631d.sol
| 3,318 | 12,539 |
pragma solidity 0.4.24;
contract ERC20 {
// modifiers
// mitigate short address attack
// TODO: doublecheck implication of >= compared to ==
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
}
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed from, uint256 value);
event SaleContractActivation(address saleContract, uint256 tokensForSale);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
address public creater;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable(address _owner) public {
creater = msg.sender;
if (_owner != 0) {
owner = _owner;
}
else {
owner = creater;
}
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier isCreator() {
require(msg.sender == creater);
_;
}
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Balance of owner
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param _to Address of token receiver
/// @param _value Number of tokens to transfer
/// @return Was transfer successful?
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0 && balances[_to].add(_value) > balances[_to]) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value); // solhint-disable-line
return true;
} else {
return false;
}
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success
/// @param _from Address from where tokens are withdrawn
/// @param _to Address to where tokens are sent
/// @param _value Number of tokens to transfer
/// @return Was transfer successful?
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) 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); // solhint-disable-line
return true;
}
function approve(address _spender, uint256 _value) public onlyPayloadSize(2) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(_value == 0 && (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); // solhint-disable-line
return true;
}
function changeApproval(address _spender, uint256 _oldValue, uint256 _newValue) public onlyPayloadSize(3) returns (bool success) {
require(allowed[msg.sender][_spender] == _oldValue);
allowed[msg.sender][_spender] = _newValue;
emit Approval(msg.sender, _spender, _newValue); // solhint-disable-line
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function burn(uint256 _value) public returns (bool burnSuccess) {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value); // solhint-disable-line
return true;
}
}
contract TravelHelperToken is StandardToken, Ownable {
//Begin: state variables
address public saleContract;
string public constant name = "TravelHelperToken";
string public constant symbol = "TRH";
uint public constant decimals = 18;
bool public fundraising = true;
uint public totalReleased = 0;
address public teamAddressOne;
address public teamAddressTwo;
address public marketingAddress;
address public advisorsAddress;
address public teamAddressThree;
uint public icoStartBlock;
uint256 public tokensUnlockPeriod = 37 days / 15; // 7 days presale + 30 days crowdsale
uint public tokensSupply = 5000000000; // 5 billion
uint public teamTokens = 1480000000 * 1 ether; // 1.48 billion
uint public teamAddressThreeTokens = 20000000 * 1 ether; // 20 million
uint public marketingTeamTokens = 500000000 * 1 ether; // 500 million
uint public advisorsTokens = 350000000 * 1 ether; // 350 million
uint public bountyTokens = 150000000 * 1 ether; //150 million
uint public tokensForSale = 2500000000 * 1 ether; // 2.5 billion
uint public releasedTeamTokens = 0;
uint public releasedAdvisorsTokens = 0;
uint public releasedMarketingTokens = 0;
bool public tokensLocked = true;
Ownable ownable;
mapping (address => bool) public frozenAccounts;
//End: state variables
//Begin: events
event FrozenFund(address target, bool frozen);
event PriceLog(string text);
//End: events
//Begin: modifiers
modifier manageTransfer() {
if (msg.sender == owner) {
_;
}
else {
require(fundraising == false);
_;
}
}
modifier tokenNotLocked() {
if (icoStartBlock > 0 && block.number.sub(icoStartBlock) > tokensUnlockPeriod) {
tokensLocked = false;
_;
} else {
revert();
}
}
//End: modifiers
//Begin: constructor
function TravelHelperToken(address _tokensOwner,
address _teamAddressOne,
address _teamAddressTwo,
address _marketingAddress,
address _advisorsAddress,
address _teamAddressThree) public Ownable(_tokensOwner) {
require(_tokensOwner != 0x0);
require(_teamAddressOne != 0x0);
require(_teamAddressTwo != 0x0);
teamAddressOne = _teamAddressOne;
teamAddressTwo = _teamAddressTwo;
advisorsAddress = _advisorsAddress;
marketingAddress = _marketingAddress;
teamAddressThree = _teamAddressThree;
totalSupply = tokensSupply * (uint256(10) ** decimals);
}
//End: constructor
//Begin: overriden methods
function transfer(address _to, uint256 _value) public manageTransfer onlyPayloadSize(2) returns (bool success) {
require(_to != address(0));
require(!frozenAccounts[msg.sender]);
super.transfer(_to,_value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
manageTransfer
onlyPayloadSize(3) returns (bool)
{
require(_to != address(0));
require(_from != address(0));
require(!frozenAccounts[msg.sender]);
super.transferFrom(_from,_to,_value);
return true;
}
//End: overriden methods
//Being: setters
function activateSaleContract(address _saleContract) public onlyOwner {
require(tokensForSale > 0);
require(teamTokens > 0);
require(_saleContract != address(0));
require(saleContract == address(0));
saleContract = _saleContract;
uint totalValue = teamTokens.mul(50).div(100);
balances[teamAddressOne] = balances[teamAddressOne].add(totalValue);
balances[teamAddressTwo] = balances[teamAddressTwo].add(totalValue);
balances[advisorsAddress] = balances[advisorsAddress].add(advisorsTokens);
balances[teamAddressThree] = balances[teamAddressThree].add(teamAddressThreeTokens);
balances[marketingAddress] = balances[marketingAddress].add(marketingTeamTokens);
releasedTeamTokens = releasedTeamTokens.add(teamTokens);
releasedAdvisorsTokens = releasedAdvisorsTokens.add(advisorsTokens);
releasedMarketingTokens = releasedMarketingTokens.add(marketingTeamTokens);
balances[saleContract] = balances[saleContract].add(tokensForSale);
totalReleased = totalReleased.add(tokensForSale).add(teamTokens).add(advisorsTokens).add(teamAddressThreeTokens).add(marketingTeamTokens);
tokensForSale = 0;
teamTokens = 0;
teamAddressThreeTokens = 0;
icoStartBlock = block.number;
assert(totalReleased <= totalSupply);
emit Transfer(address(this), teamAddressOne, totalValue);
emit Transfer(address(this), teamAddressTwo, totalValue);
emit Transfer(address(this),teamAddressThree,teamAddressThreeTokens);
emit Transfer(address(this), saleContract, 2500000000 * 1 ether);
emit SaleContractActivation(saleContract, 2500000000 * 1 ether);
}
function saleTransfer(address _to, uint256 _value) public returns (bool) {
require(saleContract != address(0));
require(msg.sender == saleContract);
return super.transfer(_to, _value);
}
function burnTokensForSale() public returns (bool) {
require(saleContract != address(0));
require(msg.sender == saleContract);
uint256 tokens = balances[saleContract];
require(tokens > 0);
require(tokens <= totalSupply);
balances[saleContract] = 0;
totalSupply = totalSupply.sub(tokens);
emit Burn(saleContract, tokens);
return true;
}
function finalize() public {
require(fundraising != false);
require(msg.sender == saleContract);
// Switch to Operational state. This is the only place this can happen.
fundraising = false;
}
function freezeAccount (address target, bool freeze) public onlyOwner {
require(target != 0x0);
require(freeze == (true || false));
frozenAccounts[target] = freeze;
emit FrozenFund(target, freeze); // solhint-disable-line
}
function sendBounty(address _to, uint256 _value) public onlyOwner returns (bool) {
uint256 value = _value.mul(1 ether);
require(bountyTokens >= value);
totalReleased = totalReleased.add(value);
require(totalReleased <= totalSupply);
balances[_to] = balances[_to].add(value);
bountyTokens = bountyTokens.sub(value);
emit Transfer(address(this), _to, value);
return true;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
emit OwnershipTransferred(owner, newOwner); // solhint-disable-line
}
//End: setters
function() public {
revert();
}
}
| 134,099 | 39 |
3f9dab8e64b50aa1812f976ca07604afb26c8cc19bbb67a543c870f1821cdf36
| 24,030 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc4803010115D3A537D10064f2ABCCA6a0015F649/contract.sol
| 3,903 | 15,051 |
pragma solidity =0.6.2;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
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;
}
}
// People lock their `lockToken` and get rewarded `rewardToken`
/// @notice This contract allows you to lock lockToken tokens and receive earnings
/// It also allows you to extract those earnings
contract Vault is Initializable, OwnableUpgradeSafe {
using SafeMath for uint256;
// How many lockToken tokens each user has
mapping (address => uint256) public amountLocked;
// The price when you extracted your earnings so we can whether you got new earnings or not
mapping (address => uint256) public lastPriceEarningsExtracted;
// When the user started locking his lockToken tokens
mapping (address => uint256) public depositStarts;
mapping (address => uint256) public lockingTime;
// The uniswap lockToken token contract
address public lockToken;
// The reward token that people receive based on the staking time
address public rewardToken;
// How many lockToken tokens are locked
uint256 public totalLiquidityLocked;
// The total lockTokenFee generated
uint256 public totalLockTokenFeeMined;
uint256 public lockTokenFeePrice;
uint256 public accomulatedRewards;
uint256 public pricePadding;
address payable public devTreasury;
uint256 public minTimeLock;
uint256 public maxTimeLock;
uint256 public minDevTreasuryPercentage;
uint256 public maxDevTreasuryPercentage;
// The last block number when fee was updated
uint256 public lastBlockFee;
uint256 public rewardPerBlock;
// increase the lockTokenFeePrice
receive() external payable {
addFeeAndUpdatePrice(msg.value);
}
function initialize(address _lockToken, address _rewardToken, address payable _devTreasury) public initializer {
__Ownable_init();
lockToken = _lockToken;
pricePadding = 1e18;
devTreasury = _devTreasury;
minTimeLock = 30 days;
maxTimeLock = 365 days;
minDevTreasuryPercentage = 50e18;
maxDevTreasuryPercentage = 10e18;
lastBlockFee = 0;
rewardToken = _rewardToken;
// The average block time is 3 seconds, therefore 1 day is 28800 blocks
// 1e18 / 28800 is 1 onek per 28800 blocks (a day on average in BSC)
rewardPerBlock = 35e12;
}
function setLockToken(address _lockToken) external onlyOwner {
lockToken = _lockToken;
}
// Must be in 1e18 since it's using the pricePadding
function setRewardPerBlock(uint256 _rewardPerBlock) external onlyOwner {
rewardPerBlock = _rewardPerBlock;
}
function setDevTreasury(address payable _devTreasury) external onlyOwner {
devTreasury = _devTreasury;
}
function setRewardToken(address _rewardToken) external onlyOwner {
rewardToken = _rewardToken;
}
// Must be in seconds
function setTimeLocks(uint256 _minTimeLock, uint256 _maxTimeLock) external onlyOwner {
minTimeLock = _minTimeLock;
maxTimeLock = _maxTimeLock;
}
function setDevPercentages(uint256 _minDevTreasuryPercentage, uint256 _maxDevTreasuryPercentage) external onlyOwner {
require(minDevTreasuryPercentage > maxDevTreasuryPercentage, 'Vault: The min % must be larger');
minDevTreasuryPercentage = _minDevTreasuryPercentage;
maxDevTreasuryPercentage = _maxDevTreasuryPercentage;
}
/// @notice When ETH is added, the price is increased
/// Price is = (feeIn / totalLockTokenFeeDistributed) + currentPrice
/// padded with 18 zeroes that get removed after the calculations
/// if there are no locked lockTokens, the price is 0
function addFeeAndUpdatePrice(uint256 _feeIn) internal {
accomulatedRewards = accomulatedRewards.add(_feeIn);
if (totalLiquidityLocked == 0) {
lockTokenFeePrice = 0;
} else {
lockTokenFeePrice = (_feeIn.mul(pricePadding).div(totalLiquidityLocked)).add(lockTokenFeePrice);
}
}
/// @notice To calculate how much fee should be added based on time
function updateFeeIn() internal {
// setup the intial block instead of getting rewards right away
if (lastBlockFee != 0) {
// Use it
uint256 blocksPassed = block.number - lastBlockFee;
uint256 feeIn = blocksPassed.mul(rewardPerBlock);
if (feeIn > 0) addFeeAndUpdatePrice(feeIn);
// Update it
}
lastBlockFee = block.number;
}
// The time lock is reset every new deposit
function lockLiquidity(uint256 _amount, uint256 _timeLock) public {
updateFeeIn();
require(_amount > 0, 'Vault: Amount must be larger than zero');
require(_timeLock >= minTimeLock && _timeLock <= maxTimeLock, 'Vault: You must setup a locking time between the ranges');
// Transfer lockToken tokens inside here while earning fees from every transfer
uint256 approval = IERC20(lockToken).allowance(msg.sender, address(this));
require(approval >= _amount, 'Vault: You must approve the desired amount of lockToken tokens to this contract first');
IERC20(lockToken).transferFrom(msg.sender, address(this), _amount);
totalLiquidityLocked = totalLiquidityLocked.add(_amount);
// Extract earnings in case the user is not a new Locked lockToken
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != lockTokenFeePrice) {
extractEarnings();
}
// Set the initial price
if (lockTokenFeePrice == 0) {
lockTokenFeePrice = accomulatedRewards.mul(pricePadding).div(_amount).add(1e18);
lastPriceEarningsExtracted[msg.sender] = 1e18;
} else {
lastPriceEarningsExtracted[msg.sender] = lockTokenFeePrice;
}
// The price doesn't change when locking lockToken. It changes when fees are generated from transfers
amountLocked[msg.sender] = amountLocked[msg.sender].add(_amount);
// Notice that the locking time is reset when new lockToken is added
depositStarts[msg.sender] = now;
lockingTime[msg.sender] = _timeLock;
}
// We check for new earnings by seeing if the price the user last extracted his earnings
// is the same or not to determine whether he can extract new earnings or not
function extractEarnings() public {
updateFeeIn();
require(amountLocked[msg.sender] > 0, 'Vault: You must have locked lockToken provider tokens to extract your earnings');
require(lockTokenFeePrice != lastPriceEarningsExtracted[msg.sender], 'Vault: You have already extracted your earnings');
// The amountLocked price minus the last price extracted
uint256 myPrice = lockTokenFeePrice.sub(lastPriceEarningsExtracted[msg.sender]);
uint256 earnings = amountLocked[msg.sender].mul(myPrice).div(pricePadding);
lastPriceEarningsExtracted[msg.sender] = lockTokenFeePrice;
accomulatedRewards = accomulatedRewards.sub(earnings);
uint256 devTreasuryPercentage = calcDevTreasuryPercentage(lockingTime[msg.sender]);
uint256 devTreasuryEarnings = earnings.mul(devTreasuryPercentage).div(1e20);
uint256 remaining = earnings.sub(devTreasuryEarnings);
// Transfer the earnings
IERC20(rewardToken).transfer(devTreasury, devTreasuryEarnings);
IERC20(rewardToken).transfer(msg.sender, remaining);
}
// The user must lock the lockToken for 1 year and only then can extract his Locked lockToken tokens
// he must extract all the lockTokens for simplicity and security purposes
function extractLiquidity() public {
updateFeeIn();
require(amountLocked[msg.sender] > 0, 'Vault: You must have locked lockTokens to extract them');
require(now.sub(depositStarts[msg.sender]) >= lockingTime[msg.sender], 'Vault: You must wait the specified locking time to extract your lockToken provider tokens');
// Extract earnings in case there are some
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != lockTokenFeePrice) {
extractEarnings();
}
uint256 locked = amountLocked[msg.sender];
amountLocked[msg.sender] = 0;
depositStarts[msg.sender] = now;
lastPriceEarningsExtracted[msg.sender] = 0;
totalLiquidityLocked = totalLiquidityLocked.sub(locked);
IERC20(lockToken).transfer(msg.sender, locked);
}
/// Returns the treasury percentage padded with 18 zeroes
function calcDevTreasuryPercentage(uint256 _lockingTime) public view returns(uint256) {
require(_lockingTime >= minTimeLock && _lockingTime <= maxTimeLock, 'Vault: You must setup a locking time between the ranges');
if (_lockingTime == maxTimeLock) {
return maxDevTreasuryPercentage;
}
if (_lockingTime == minTimeLock) {
return minDevTreasuryPercentage;
}
uint256 padding = 1e18;
uint256 combinedDays = maxTimeLock.sub(minTimeLock);
uint256 combinedFee = minDevTreasuryPercentage.sub(maxDevTreasuryPercentage);
// There's no risk of a ratio == 0 since we return the right percentage when lockTime == minLockTime
uint256 ratio = (_lockingTime.sub(minTimeLock)).mul(padding).div(combinedDays);
return minDevTreasuryPercentage.sub(ratio.mul(combinedFee).div(padding));
}
function getAmountLocked(address _user) external view returns(uint256) {
return amountLocked[_user];
}
function extractTokensIfStuck(address _token, uint256 _amount) external onlyOwner {
IERC20(_token).transfer(owner(), _amount);
}
function extractETHIfStruck() external onlyOwner {
payable(address(owner())).transfer(address(this).balance);
}
}
| 252,526 | 40 |
24bb9988db1f2f5263de3d5183f1ca86a7391afc3f6025d75cfffd4649c61327
| 11,931 |
.sol
|
Solidity
| false |
428503962
|
PawnHouseOfficial/PawnHouse
|
ca6ef93968c53103e719be8c2c0e22966e8231fa
|
PHSigningUtils.sol
| 2,519 | 10,613 |
pragma solidity ^0.5.16;
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
// Check the signature length
if (signature.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
// 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)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
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));
}
}
// @title Helper contract for PH. This contract manages verifying signatures
// from off-chain PH orders.
// @author smartcontractdev.eth, creator of wrappedkitties.eth, cwhelper.eth,
// and kittybounties.eth
// @notice Cite: I found the following article very insightful while creating
// this contract:
// https://dzone.com/articles/signing-and-verifying-ethereum-signatures
// @notice Cite: I also relied on this article somewhat:
contract PHSigningUtils {
constructor() internal {}
// @notice OpenZeppelin's ECDSA library is used to call all ECDSA functions
// directly on the bytes32 variables themselves.
using ECDSA for bytes32;
// @notice This function gets the current chain ID.
function getChainID() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
// @notice This function is called in PH.beginLoan() to validate the
// borrower's signature that the borrower provided off-chain to
// verify that they did indeed want to use this NFT for this loan.
// @param _nftCollateralId - The ID within the NFTCollateralContract for
// the NFT being used as collateral for this loan. The NFT is
// stored within this contract during the duration of the loan.
// @param _borrowerNonce - The nonce referred to here
// is not the same as an Ethereum account's nonce. We are referring
// instead to nonces that are used by both the lender and the
// borrower when they are first signing off-chain PH orders.
// These nonces can be any uint256 value that the user has not
// previously used to sign an off-chain order. Each nonce can be
// used at most once per user within PH, regardless of whether
// they are the lender or the borrower in that situation. This
// serves two purposes. First, it prevents replay attacks where an
// attacker would submit a user's off-chain order more than once.
// Second, it allows a user to cancel an off-chain order by calling
// PH.cancelLoanCommitmentBeforeLoanHasBegun(), which marks the
// nonce as used and prevents any future loan from using the user's
// off-chain order that contains that nonce.
// @param _nftCollateralContract - The ERC721 contract of the NFT
// collateral
// @param _borrower - The address of the borrower.
// @param _borrowerSignature - The ECDSA signature of the borrower,
// obtained off-chain ahead of time, signing the following
// combination of parameters: _nftCollateralId, _borrowerNonce,
// _nftCollateralContract, _borrower.
// @return A bool representing whether verification succeeded, showing that
// this signature matched this address and parameters.
function isValidLenderSignature(uint256 _nftCollateralId,
uint256 _lenderNonce,
address _nftCollateralContract,
address _lender,
bytes memory _lenderSignature) public view returns(bool) {
if(_lender == address(0)){
return false;
} else {
uint256 chainId;
chainId = getChainID();
bytes32 message = keccak256(abi.encodePacked(_nftCollateralId,
_lenderNonce,
_nftCollateralContract,
_lender,
chainId));
bytes32 messageWithEthSignPrefix = message.toEthSignedMessageHash();
return (messageWithEthSignPrefix.recover(_lenderSignature) == _lender);
}
}
// @notice This function is called in PH.beginLoan() to validate the
// lender's signature that the lender provided off-chain to
// verify that they did indeed want to agree to this loan according
// to these terms.
// @param _loanPrincipalAmount - The original sum of money transferred
// from lender to borrower at the beginning of the loan, measured
// in loanERC20Denomination's smallest units.
// @param _maximumRepaymentAmount - The maximum amount of money that the
// borrower would be required to retrieve their collateral. If
// interestIsProRated is set to false, then the borrower will
// always have to pay this amount to retrieve their collateral.
// @param _nftCollateralId - The ID within the NFTCollateralContract for
// the NFT being used as collateral for this loan. The NFT is
// stored within this contract during the duration of the loan.
// @param _loanDuration - The amount of time (measured in seconds) that can
// elapse before the lender can liquidate the loan and seize the
// underlying collateral NFT.
// @param _loanInterestRateForDurationInBasisPoints - The interest rate
// (measured in basis points, e.g. hundreths of a percent) for the
// loan, that must be repaid pro-rata by the borrower at the
// conclusion of the loan or risk seizure of their nft collateral.
// @param _adminFeeInBasisPoints - The percent (measured in basis
// points) of the interest earned that will be taken as a fee by
// the contract admins when the loan is repaid. The fee is stored
// in the loan struct to prevent an attack where the contract
// admins could adjust the fee right before a loan is repaid, and
// take all of the interest earned.
// @param _lenderNonce - The nonce referred to here
// is not the same as an Ethereum account's nonce. We are referring
// instead to nonces that are used by both the lender and the
// borrower when they are first signing off-chain PH orders.
// These nonces can be any uint256 value that the user has not
// previously used to sign an off-chain order. Each nonce can be
// used at most once per user within PH, regardless of whether
// they are the lender or the borrower in that situation. This
// serves two purposes. First, it prevents replay attacks where an
// attacker would submit a user's off-chain order more than once.
// Second, it allows a user to cancel an off-chain order by calling
// PH.cancelLoanCommitmentBeforeLoanHasBegun(), which marks the
// nonce as used and prevents any future loan from using the user's
// off-chain order that contains that nonce.
// @param _nftCollateralContract - The ERC721 contract of the NFT
// collateral
// @param _loanERC20Denomination - The ERC20 contract of the currency being
// used as principal/interest for this loan.
// @param _lender - The address of the lender. The lender can change their
// address by transferring the PH ERC721 token that they
// received when the loan began.
// @param _interestIsProRated - A boolean value determining whether the
// interest will be pro-rated if the loan is repaid early, or
// whether the borrower will simply pay maximumRepaymentAmount.
// @param _lenderSignature - The ECDSA signature of the lender,
// obtained off-chain ahead of time, signing the following
// combination of parameters: _loanPrincipalAmount,
// _maximumRepaymentAmount _nftCollateralId, _loanDuration,
// _loanInterestRateForDurationInBasisPoints, _lenderNonce,
// _nftCollateralContract, _loanERC20Denomination, _lender,
// _interestIsProRated.
// @return A bool representing whether verification succeeded, showing that
// this signature matched this address and parameters.
function isValidBorrowSignature(uint256 _loanPrincipalAmount,
uint256 _maximumRepaymentAmount,
uint256 _nftCollateralId,
uint256 _loanDuration,
uint256 _loanInterestRateForDurationInBasisPoints,
uint256 _adminFeeInBasisPoints,
uint256 _borrowerNonce,
address _nftCollateralContract,
address _loanERC20Denomination,
address _borrower,
bool _interestIsProRated,
bytes memory _lenderSignature) public view returns(bool) {
if(_borrower == address(0)){
return false;
} else {
uint256 chainId;
chainId = getChainID();
bytes32 message = keccak256(abi.encodePacked(_loanPrincipalAmount,
_maximumRepaymentAmount,
_nftCollateralId,
_loanDuration,
_loanInterestRateForDurationInBasisPoints,
_adminFeeInBasisPoints,
_borrowerNonce,
_nftCollateralContract,
_loanERC20Denomination,
_borrower,
_interestIsProRated,
chainId));
bytes32 messageWithEthSignPrefix = message.toEthSignedMessageHash();
return (messageWithEthSignPrefix.recover(_lenderSignature) == _borrower);
}
}
}
| 17,336 | 41 |
8084d012d87e9ea72f8a331a6e15c54071e8f3db3bceccd5cb097ecc3d9b0b43
| 29,850 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/72/72633d2d3ff61f787e5d180793832c4ac189935e_OlympusLPStaking.sol
| 4,590 | 17,669 |
// SPDX-License-Identifier: AGPL-3.0-or-later\
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
// require(address(this).balance >= value, "Address: insufficient balance for call");
// return _functionCallWithValue(target, data, value, errorMessage);
// }
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IRewardToken is IERC20 {
function unwrap(address to, uint256 amount) external;
}
contract OlympusLPStaking {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using SafeERC20 for IRewardToken;
modifier onlyOwner() {
require(msg.sender == owner, "Owner only");
_;
}
struct User {
uint256 _LPDeposited;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _totalStaked, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _time);
event TransferredOwnership(address _previous, address _next, uint256 _time);
IERC20 public immutable lpToken;
IRewardToken public immutable rewardToken;
address public immutable rewardPool;
address public owner;
uint256 public rewardPerSecond;
uint256 public accRewardPerShare;
uint256 public lastRewardTimestamp;
uint256 public totalStaked;
mapping(address => User) public userDetails;
// Constructor will set the address of OHM/ETH LP token
constructor(address _lpToken, address _rewardToken, address _rewardPool, uint256 _rewardPerSecond, uint _secondsToWait) {
lpToken = IERC20(_lpToken);
rewardToken = IRewardToken(_rewardToken);
rewardPool = _rewardPool;
lastRewardTimestamp = block.timestamp.add(_secondsToWait);
rewardPerSecond = _rewardPerSecond;
accRewardPerShare;
owner = msg.sender;
}
function transferOwnership(address _owner) external onlyOwner() returns (bool) {
address previousOwner = owner;
owner = _owner;
emit TransferredOwnership(previousOwner, owner, block.timestamp);
return true;
}
// Sets OHM reward for each block
function setRewardPerSecond(uint256 _rewardPerSecond) external onlyOwner() returns (bool) {
rewardPerSecond = _rewardPerSecond;
return true;
}
// Function that will get balance of a certain stake
function getUserBalance(address _staker) external view returns(uint256 _amountStaked) {
return userDetails[_staker]._LPDeposited;
}
// Function that returns User's pending rewards
function pendingRewards(address _staker) external view returns(uint256) {
User storage user = userDetails[_staker];
uint256 _accRewardPerShare = accRewardPerShare;
if (block.timestamp > lastRewardTimestamp && totalStaked != 0) {
uint256 secondsToReward = block.timestamp.sub(lastRewardTimestamp);
uint256 reward = secondsToReward.mul(rewardPerSecond);
_accRewardPerShare = _accRewardPerShare.add(reward.mul(1e18).div(totalStaked));
}
return user._LPDeposited.mul(_accRewardPerShare).div(1e18).sub(user._rewardDebt);
}
// Function that updates OHM/DAI LP pool
function updatePool() public returns (bool) {
if (block.timestamp <= lastRewardTimestamp) {
return true;
}
if (totalStaked == 0) {
lastRewardTimestamp = block.timestamp;
return true;
}
uint256 secondsToReward = block.timestamp.sub(lastRewardTimestamp);
lastRewardTimestamp = block.timestamp;
uint256 reward = secondsToReward.mul(rewardPerSecond);
accRewardPerShare = accRewardPerShare.add(reward.mul(1e18).div(totalStaked));
rewardToken.safeTransferFrom(rewardPool, address(this), reward);
emit PoolUpdated(secondsToReward, reward, block.timestamp);
return true;
}
// Function that lets user stake OHM/DAI LP
function stakeLP(uint256 _amount) external returns (bool) {
require(_amount > 0, "Can not stake 0 LP tokens");
updatePool();
User storage user = userDetails[msg.sender];
if(user._LPDeposited > 0) {
uint256 _pendingRewards = user._LPDeposited.mul(accRewardPerShare).div(1e18).sub(user._rewardDebt);
if(_pendingRewards > 0) {
rewardToken.unwrap(msg.sender, _pendingRewards);
emit RewardsClaimed(msg.sender, _pendingRewards, block.timestamp);
}
}
lpToken.safeTransferFrom(msg.sender, address(this), _amount);
user._LPDeposited = user._LPDeposited.add(_amount);
totalStaked = totalStaked.add(_amount);
user._rewardDebt = user._LPDeposited.mul(accRewardPerShare).div(1e18);
emit StakeCompleted(msg.sender, _amount, user._LPDeposited, block.timestamp);
return true;
}
// Function that will allow user to claim rewards
function claimRewards() external returns (bool) {
updatePool();
User storage user = userDetails[msg.sender];
uint256 _pendingRewards = user._LPDeposited.mul(accRewardPerShare).div(1e18).sub(user._rewardDebt);
user._rewardDebt = user._LPDeposited.mul(accRewardPerShare).div(1e18);
require(_pendingRewards > 0, "No rewards to claim!");
rewardToken.unwrap(msg.sender, _pendingRewards);
emit RewardsClaimed(msg.sender, _pendingRewards, block.timestamp);
return true;
}
// Function that lets user unstake OHM/DAI LP in system
function unstakeLP() external returns (bool) {
updatePool();
User storage user = userDetails[msg.sender];
require(user._LPDeposited > 0, "User has no stake");
uint256 _pendingRewards = user._LPDeposited.mul(accRewardPerShare).div(1e18).sub(user._rewardDebt);
uint256 beingWithdrawn = user._LPDeposited;
user._LPDeposited = 0;
user._rewardDebt = 0;
totalStaked = totalStaked.sub(beingWithdrawn);
lpToken.safeTransfer(msg.sender, beingWithdrawn);
rewardToken.unwrap(msg.sender, _pendingRewards);
emit WithdrawCompleted(msg.sender, beingWithdrawn, block.timestamp);
emit RewardsClaimed(msg.sender, _pendingRewards, block.timestamp);
return true;
}
}
| 115,616 | 42 |
2e14a7a3a9543d8ef53112201f487ee2415fa84e81bf2583726abde1b52399e6
| 17,103 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a2/A21121b3DfD558a3A91d508049D1454073c134D4_SwapTokenLockerFactory.sol
| 2,943 | 11,681 |
// SPDX-License-Identifier: UNLICENCED
pragma solidity ^0.6.12;
contract SwapAdmin {
address public admin;
address public candidate;
constructor(address _admin) public {
require(_admin != address(0), "admin address cannot be 0");
admin = _admin;
emit AdminChanged(address(0), _admin);
}
function setCandidate(address _candidate) external onlyAdmin {
address old = candidate;
candidate = _candidate;
emit candidateChanged(old, candidate);
}
function becomeAdmin() external {
require(msg.sender == candidate, "Only candidate can become admin");
address old = admin;
admin = candidate;
emit AdminChanged(old, admin);
}
modifier onlyAdmin {
require((msg.sender == admin), "Only the contract admin can perform this action");
_;
}
event candidateChanged(address oldCandidate, address newCandidate);
event AdminChanged(address oldAdmin, address 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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract SwapTokenLocker is SwapAdmin, Context {
using SafeMath for uint;
struct LockInfo {
uint128 amount;
uint128 claimedAmount;
uint64 lockTimestamp;
uint64 lastUpdated;
uint32 lockHours;
}
address immutable token;
address public companyWallet;
uint256 public feesInETH;
mapping (address => LockInfo) public lockData;
constructor(address _admin, address _token, uint256 _feesInETH, address _companyWallet) public SwapAdmin(_admin) {
token = _token;
feesInETH = _feesInETH;
companyWallet = _companyWallet;
}
function getToken() external view returns(address) {
return token;
}
function emergencyWithdraw(address _tokenAddress) external onlyAdmin {
require(_tokenAddress != address(0), "Token address is invalid");
IERC20(_tokenAddress).transfer(msg.sender, IERC20(_tokenAddress).balanceOf(address(this)));
}
function getLockData(address _user) external view returns(uint128, uint128, uint64, uint64, uint32) {
require(_user != address(0), "User address is invalid");
LockInfo storage _lockInfo = lockData[_user];
return (_lockInfo.amount,
_lockInfo.claimedAmount,
_lockInfo.lockTimestamp,
_lockInfo.lastUpdated,
_lockInfo.lockHours);
}
function sendLockTokenMany(address[] calldata _users,
uint128[] calldata _amounts,
uint32[] calldata _lockHours,
uint256 _sendAmount) public payable onlyAdmin {
require(_users.length == _amounts.length, "array length not eq");
require(_users.length == _lockHours.length, "array length not eq");
require(_sendAmount > 0 , "Amount is invalid");
if (feesInETH > 0) {
if (companyWallet != address(0)) {
uint256 minAmount = feesInETH.mul(10 ** 18);
require(msg.value >= minAmount, "Low fee amount");
uint256 feeDiff = msg.value - minAmount;
(bool success,) = companyWallet.call{value: minAmount}("");
require(success, "Fee transfer failed");
if (feeDiff > 0) {
(bool refundSuccess,) = _msgSender().call{value: feeDiff}("");
require(refundSuccess, "Fee refund failed");
}
} else {
(bool refundSuccess,) = _msgSender().call{value: msg.value}("");
require(refundSuccess, "Fee refund failed");
}
}
IERC20(token).transferFrom(msg.sender, address(this), _sendAmount);
for (uint256 j = 0; j < _users.length; j++) {
sendLockToken(_users[j], _amounts[j], uint64(block.timestamp), _lockHours[j]);
}
}
function sendLockToken(address _user,
uint128 _amount,
uint64 _lockTimestamp,
uint32 _lockHours) internal {
require(_amount > 0, "amount can not zero");
require(_lockHours > 0, "lock hours need more than zero");
require(_lockTimestamp > 0, "lock timestamp need more than zero");
require(lockData[_user].amount == 0, "this address has already locked");
LockInfo memory lockinfo = LockInfo({
amount: _amount,
lockTimestamp: _lockTimestamp,
lockHours: _lockHours,
lastUpdated: uint64(block.timestamp),
claimedAmount: 0
});
lockData[_user] = lockinfo;
}
function claimToken(uint128 _amount) external returns (uint256) {
require(_amount > 0, "Invalid parameter amount");
address _user = msg.sender;
LockInfo storage _lockInfo = lockData[_user];
require(_lockInfo.lockTimestamp <= block.timestamp, "Vesting time is not started");
require(_lockInfo.amount > 0, "No lock token to claim");
uint256 passhours = block.timestamp.sub(_lockInfo.lockTimestamp).div(1 hours);
require(passhours > 0, "need wait for one hour at least");
require((block.timestamp - _lockInfo.lastUpdated) > 1 hours, "You have to wait at least an hour to claim");
uint256 available = 0;
if (passhours >= _lockInfo.lockHours) {
available = _lockInfo.amount;
} else {
available = uint256(_lockInfo.amount).div(_lockInfo.lockHours).mul(passhours);
}
available = available.sub(_lockInfo.claimedAmount);
require(available > 0, "not available claim");
uint256 claim = _amount;
if (_amount > available) { // claim as much as possible
claim = available;
}
_lockInfo.claimedAmount = uint128(uint256(_lockInfo.claimedAmount).add(claim));
IERC20(token).transfer(_user, claim);
_lockInfo.lastUpdated = uint64(block.timestamp);
return claim;
}
}
contract SwapTokenLockerFactory is Ownable {
event SwapTokenLockerCreated(address admin, address locker);
mapping(address => address[]) private deployedContracts;
address[] private allLockers;
uint256 public feesInETH = 1;
address payable public companyWallet;
constructor() public {
companyWallet = payable(msg.sender);
}
function getLastDeployed(address owner) external view returns(address locker) {
uint256 length = deployedContracts[owner].length;
return deployedContracts[owner][length - 1];
}
function getAllContracts() external view returns (address[] memory) {
return allLockers;
}
function getDeployed(address owner) external view returns(address[] memory) {
return deployedContracts[owner];
}
function createTokenLocker(address token) external returns (address locker) {
SwapTokenLocker lockerContract = new SwapTokenLocker(msg.sender, token, feesInETH, companyWallet);
locker = address(lockerContract);
deployedContracts[msg.sender].push(locker);
allLockers.push(locker);
emit SwapTokenLockerCreated(msg.sender, locker);
}
function setFeesInETH(uint256 _feesInETH) external onlyOwner() {
feesInETH = _feesInETH;
}
function setCompanyWallet(address payable _companyWallet) external onlyOwner() {
require(_companyWallet != address(0), "Invalid wallet address");
companyWallet = _companyWallet;
}
}
| 73,293 | 43 |
de00eda1ca64748989895943694fbecc9c8dcceb2df06b65db61e53945cbb93d
| 13,709 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xdc8a6ef9a8a4114773e806dc24bb8e7b6f3d92eb.sol
| 3,261 | 11,657 |
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;
}
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);
}
}
contract CryptoEngineerInterface {
uint256 public prizePool = 0;
function subVirus(address , uint256) public pure {}
function claimPrizePool(address , uint256) public pure {}
function fallback() public payable {}
function isEngineerContract() external pure returns(bool) {}
}
interface CryptoMiningWarInterface {
function addCrystal(address , uint256) external pure;
function subCrystal(address , uint256) external pure;
function isMiningWarContract() external pure returns(bool);
}
interface MiniGameInterface {
function isContractMiniGame() external pure returns(bool _isContractMiniGame);
}
contract CryptoBossWannaCry is PullPayment{
bool init = false;
address public administrator;
uint256 public bossRoundNumber;
uint256 public BOSS_HP_DEFAULT = 10000000;
uint256 public HALF_TIME_ATK_BOSS = 0;
// engineer game infomation
uint256 constant public VIRUS_MINING_PERIOD = 86400;
uint256 public BOSS_DEF_DEFFAULT = 0;
CryptoEngineerInterface public Engineer;
CryptoMiningWarInterface public MiningWar;
// player information
mapping(address => PlayerData) public players;
// boss information
mapping(uint256 => BossData) public bossData;
mapping(address => bool) public miniGames;
struct PlayerData {
uint256 currentBossRoundNumber;
uint256 lastBossRoundNumber;
uint256 win;
uint256 share;
uint256 dame;
uint256 nextTimeAtk;
}
struct BossData {
uint256 bossRoundNumber;
uint256 bossHp;
uint256 def;
uint256 prizePool;
address playerLastAtk;
uint256 totalDame;
bool ended;
}
event eventAttackBoss(uint256 bossRoundNumber,
address playerAtk,
uint256 virusAtk,
uint256 dame,
uint256 totalDame,
uint256 timeAtk,
bool isLastHit,
uint256 crystalsReward);
event eventEndAtkBoss(uint256 bossRoundNumber,
address playerWin,
uint256 ethBonus,
uint256 bossHp,
uint256 prizePool);
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
modifier isAdministrator()
{
require(msg.sender == administrator);
_;
}
constructor() public {
administrator = msg.sender;
// set interface contract
setMiningWarInterface(0x65c347702b66ff8f1a28cf9a9768487fbe97765f);
setEngineerInterface(0xb2d6000d4a7fe8b1358d54a9bc21f2badf91d849);
}
function () public payable
{
}
function isContractMiniGame() public pure returns(bool _isContractMiniGame)
{
_isContractMiniGame = true;
}
function isBossWannaCryContract() public pure returns(bool)
{
return true;
}
function setupMiniGame(uint256 , uint256) public
{
}
//@dev use this function in case of bug
function upgrade(address addr) public isAdministrator
{
selfdestruct(addr);
}
// ---------------------------------------------------------------------------------------
// SET INTERFACE CONTRACT
// ---------------------------------------------------------------------------------------
function setMiningWarInterface(address _addr) public isAdministrator
{
CryptoMiningWarInterface miningWarInterface = CryptoMiningWarInterface(_addr);
require(miningWarInterface.isMiningWarContract() == true);
MiningWar = miningWarInterface;
}
function setEngineerInterface(address _addr) public isAdministrator
{
CryptoEngineerInterface engineerInterface = CryptoEngineerInterface(_addr);
require(engineerInterface.isEngineerContract() == true);
Engineer = engineerInterface;
}
function setContractsMiniGame(address _addr) public isAdministrator
{
MiniGameInterface MiniGame = MiniGameInterface(_addr);
if(MiniGame.isContractMiniGame() == false) { revert(); }
miniGames[_addr] = true;
}
function setBossRoundNumber(uint256 _value) public isAdministrator
{
bossRoundNumber = _value;
}
function removeContractMiniGame(address _addr) public isAdministrator
{
miniGames[_addr] = false;
}
function startGame() public isAdministrator
{
require(init == false);
init = true;
bossData[bossRoundNumber].ended = true;
startNewBoss();
}
function setDefenceBoss(uint256 _value) public isAdministrator
{
BOSS_DEF_DEFFAULT = _value;
}
function setBossHPDefault(uint256 _value) public isAdministrator
{
BOSS_HP_DEFAULT = _value;
}
function setHalfTimeAtkBoss(uint256 _value) public isAdministrator
{
HALF_TIME_ATK_BOSS = _value;
}
function startNewBoss() private
{
require(bossData[bossRoundNumber].ended == true);
bossRoundNumber = bossRoundNumber + 1;
uint256 bossHp = BOSS_HP_DEFAULT * bossRoundNumber;
// claim 5% of current prizePool as rewards.
uint256 engineerPrizePool = Engineer.prizePool();
uint256 prizePool = SafeMath.div(SafeMath.mul(engineerPrizePool, 5),100);
Engineer.claimPrizePool(address(this), prizePool);
bossData[bossRoundNumber] = BossData(bossRoundNumber, bossHp, BOSS_DEF_DEFFAULT, prizePool, 0x0, 0, false);
}
function endAtkBoss() private
{
require(bossData[bossRoundNumber].ended == false);
require(bossData[bossRoundNumber].totalDame >= bossData[bossRoundNumber].bossHp);
BossData storage b = bossData[bossRoundNumber];
b.ended = true;
// update eth bonus for player last hit
uint256 ethBonus = SafeMath.div(SafeMath.mul(b.prizePool, 5), 100);
if (b.playerLastAtk != 0x0) {
PlayerData storage p = players[b.playerLastAtk];
p.win = p.win + ethBonus;
uint256 share = SafeMath.div(SafeMath.mul(SafeMath.mul(b.prizePool, 95), p.dame), SafeMath.mul(b.totalDame, 100));
ethBonus += share;
}
emit eventEndAtkBoss(bossRoundNumber, b.playerLastAtk, ethBonus, b.bossHp, b.prizePool);
startNewBoss();
}
function atkBoss(uint256 _value) public disableContract
{
require(bossData[bossRoundNumber].ended == false);
require(bossData[bossRoundNumber].totalDame < bossData[bossRoundNumber].bossHp);
require(players[msg.sender].nextTimeAtk <= now);
Engineer.subVirus(msg.sender, _value);
uint256 rate = 50 + randomNumber(msg.sender, now, 60); // 50 - 110%
uint256 atk = SafeMath.div(SafeMath.mul(_value, rate), 100);
updateShareETH(msg.sender);
// update dame
BossData storage b = bossData[bossRoundNumber];
uint256 currentTotalDame = b.totalDame;
uint256 dame = 0;
if (atk > b.def) {
dame = SafeMath.sub(atk, b.def);
}
b.totalDame = SafeMath.min(SafeMath.add(currentTotalDame, dame), b.bossHp);
b.playerLastAtk = msg.sender;
dame = SafeMath.sub(b.totalDame, currentTotalDame);
// bonus crystals
uint256 crystalsBonus = SafeMath.div(SafeMath.mul(dame, 5), 100);
MiningWar.addCrystal(msg.sender, crystalsBonus);
// update player
PlayerData storage p = players[msg.sender];
p.nextTimeAtk = now + HALF_TIME_ATK_BOSS;
if (p.currentBossRoundNumber == bossRoundNumber) {
p.dame = SafeMath.add(p.dame, dame);
} else {
p.currentBossRoundNumber = bossRoundNumber;
p.dame = dame;
}
bool isLastHit;
if (b.totalDame >= b.bossHp) {
isLastHit = true;
endAtkBoss();
}
// emit event attack boss
emit eventAttackBoss(b.bossRoundNumber, msg.sender, _value, dame, p.dame, now, isLastHit, crystalsBonus);
}
function updateShareETH(address _addr) private
{
PlayerData storage p = players[_addr];
if (bossData[p.currentBossRoundNumber].ended == true &&
p.lastBossRoundNumber < p.currentBossRoundNumber) {
p.share = SafeMath.add(p.share, calculateShareETH(_addr, p.currentBossRoundNumber));
p.lastBossRoundNumber = p.currentBossRoundNumber;
}
}
function calculateShareETH(address _addr, uint256 _bossRoundNumber) public view returns(uint256 _share)
{
PlayerData memory p = players[_addr];
BossData memory b = bossData[_bossRoundNumber];
if (p.lastBossRoundNumber >= p.currentBossRoundNumber &&
p.currentBossRoundNumber != 0) {
_share = 0;
} else {
if (b.totalDame == 0) return 0;
_share = SafeMath.div(SafeMath.mul(SafeMath.mul(b.prizePool, 95), p.dame), SafeMath.mul(b.totalDame, 100)); // prizePool * 95% * playerDame / totalDame
}
if (b.ended == false) _share = 0;
}
function getCurrentReward(address _addr) public view returns(uint256 _currentReward)
{
PlayerData memory p = players[_addr];
_currentReward = SafeMath.add(p.win, p.share);
_currentReward += calculateShareETH(_addr, p.currentBossRoundNumber);
}
function withdrawReward(address _addr) public
{
updateShareETH(_addr);
PlayerData storage p = players[_addr];
uint256 reward = SafeMath.add(p.share, p.win);
if (address(this).balance >= reward && reward > 0) {
_addr.transfer(reward);
// update player
p.win = 0;
p.share = 0;
}
}
//--------------------------------------------------------------------------
// INTERNAL FUNCTION
//--------------------------------------------------------------------------
function devFee(uint256 _amount) private pure returns(uint256)
{
return SafeMath.div(SafeMath.mul(_amount, 5), 100);
}
function randomNumber(address _addr, uint256 randNonce, uint256 _maxNumber) private returns(uint256)
{
return uint256(keccak256(abi.encodePacked(now, _addr, randNonce))) % _maxNumber;
}
}
| 140,066 | 44 |
f945e906de3ac5d3914ef49e84aa3947d7413c9256d164fc6ac713668d273783
| 18,468 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/indaHashCoin(IDH)_0x5136c98a80811c3f46bdda8b5c4555cfd9f812f0.sol
| 4,104 | 15,427 |
pragma solidity ^0.4.16;
// ----------------------------------------------------------------------------
//
// IDH indaHash token public sale contract
//
// For details, please visit: https://indahash.com/ico
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// SafeMath3
//
// (no need to implement division)
//
// ----------------------------------------------------------------------------
library SafeMath3 {
function mul(uint a, uint b) internal constant returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
function sub(uint a, uint b) internal constant returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal constant returns (uint c) {
c = a + b;
assert(c >= a);
}
}
// ----------------------------------------------------------------------------
//
// Owned contract
//
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
// Events ---------------------------
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
// Modifier -------------------------
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Functions ------------------------
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != owner);
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
// Events ---------------------------
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// Functions ------------------------
function totalSupply() constant returns (uint);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20
//
// ----------------------------------------------------------------------------
contract ERC20Token is ERC20Interface, Owned {
using SafeMath3 for uint;
uint public tokensIssuedTotal = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
// Functions ------------------------
function totalSupply() constant returns (uint) {
return tokensIssuedTotal;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _amount) returns (bool success) {
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint _amount) returns (bool success) {
// approval amount cannot exceed the balance
require (balances[msg.sender] >= _amount);
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
// ----------------------------------------------------------------------------
//
// IDH public token sale
//
// ----------------------------------------------------------------------------
contract IndaHashToken is ERC20Token {
uint constant E6 = 10**6;
string public constant name = "indaHash Coin";
string public constant symbol = "IDH";
uint8 public constant decimals = 6;
address public wallet;
address public adminWallet;
uint public constant DATE_PRESALE_START = 1510153200; // 08-Nov-2017 15:00 UTC
uint public constant DATE_PRESALE_END = 1510758000; // 15-Nov-2017 15:00 UTC
uint public constant DATE_ICO_START = 1511967600; // 29-Nov-2017 15:00 UTC
uint public constant DATE_ICO_END = 1513782000; // 20-Dec-2017 15:00 UTC
uint public tokensPerEth = 3200 * E6; // rate during last ICO week
uint public constant BONUS_PRESALE = 40;
uint public constant BONUS_ICO_WEEK_ONE = 20;
uint public constant BONUS_ICO_WEEK_TWO = 10;
uint public constant TOKEN_SUPPLY_TOTAL = 400 * E6 * E6; // 400 mm tokens
uint public constant TOKEN_SUPPLY_ICO = 320 * E6 * E6; // 320 mm tokens
uint public constant TOKEN_SUPPLY_MKT = 80 * E6 * E6; // 80 mm tokens
uint public constant PRESALE_ETH_CAP = 15000 ether;
uint public constant MIN_FUNDING_GOAL = 40 * E6 * E6; // 40 mm tokens
uint public constant MIN_CONTRIBUTION = 1 ether / 2; // 0.5 Ether
uint public constant MAX_CONTRIBUTION = 300 ether;
uint public constant COOLDOWN_PERIOD = 2 days;
uint public constant CLAWBACK_PERIOD = 90 days;
uint public icoEtherReceived = 0; // Ether actually received by the contract
uint public tokensIssuedIco = 0;
uint public tokensIssuedMkt = 0;
uint public tokensClaimedAirdrop = 0;
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
mapping(address => bool) public airdropClaimed;
mapping(address => bool) public refundClaimed;
mapping(address => bool) public locked;
// Events ---------------------------
event WalletUpdated(address _newWallet);
event AdminWalletUpdated(address _newAdminWallet);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensMinted(address indexed _owner, uint _tokens, uint _balance);
event TokensIssued(address indexed _owner, uint _tokens, uint _balance, uint _etherContributed);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event LockRemoved(address indexed _participant);
// Basic Functions ------------------
function IndaHashToken() {
require(TOKEN_SUPPLY_ICO + TOKEN_SUPPLY_MKT == TOKEN_SUPPLY_TOTAL);
wallet = owner;
adminWallet = owner;
}
function () payable {
buyTokens();
}
// Information functions ------------
function atNow() constant returns (uint) {
return now;
}
function icoThresholdReached() constant returns (bool thresholdReached) {
if (tokensIssuedIco < MIN_FUNDING_GOAL) return false;
return true;
}
function isTransferable() constant returns (bool transferable) {
if (!icoThresholdReached()) return false;
if (atNow() < DATE_ICO_END + COOLDOWN_PERIOD) return false;
return true;
}
// Lock functions -------------------
function removeLock(address _participant) {
require(msg.sender == adminWallet || msg.sender == owner);
locked[_participant] = false;
LockRemoved(_participant);
}
function removeLockMultiple(address[] _participants) {
require(msg.sender == adminWallet || msg.sender == owner);
for (uint i = 0; i < _participants.length; i++) {
locked[_participants[i]] = false;
LockRemoved(_participants[i]);
}
}
// Owner Functions ------------------
function setWallet(address _wallet) onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
WalletUpdated(wallet);
}
function setAdminWallet(address _wallet) onlyOwner {
require(_wallet != address(0x0));
adminWallet = _wallet;
AdminWalletUpdated(adminWallet);
}
function updateTokensPerEth(uint _tokensPerEth) onlyOwner {
require(atNow() < DATE_PRESALE_START);
tokensPerEth = _tokensPerEth;
TokensPerEthUpdated(_tokensPerEth);
}
function mintMarketing(address _participant, uint _tokens) onlyOwner {
// check amount
require(_tokens <= TOKEN_SUPPLY_MKT.sub(tokensIssuedMkt));
// update balances
balances[_participant] = balances[_participant].add(_tokens);
tokensIssuedMkt = tokensIssuedMkt.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
// locked
locked[_participant] = true;
// log the miniting
Transfer(0x0, _participant, _tokens);
TokensMinted(_participant, _tokens, balances[_participant]);
}
function ownerClawback() external onlyOwner {
require(atNow() > DATE_ICO_END + CLAWBACK_PERIOD);
wallet.transfer(this.balance);
}
function transferAnyERC20Token(address tokenAddress, uint amount) onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
// Private functions ----------------
function buyTokens() private {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require(msg.value >= MIN_CONTRIBUTION);
// one address transfer hard cap
require(icoEtherContributed[msg.sender].add(msg.value) <= MAX_CONTRIBUTION);
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) isPresale = true;
if (ts > DATE_ICO_START && ts < DATE_ICO_END) isIco = true;
require(isPresale || isIco);
// presale cap in Ether
if (isPresale) require(icoEtherReceived.add(msg.value) <= PRESALE_ETH_CAP);
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last week)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 7 days) {
// first week ico bonus
tokens = tokens.mul(100 + BONUS_ICO_WEEK_ONE) / 100;
} else if (ts < DATE_ICO_START + 14 days) {
// second week ico bonus
tokens = tokens.mul(100 + BONUS_ICO_WEEK_TWO) / 100;
}
// ICO token volume cap
require(tokensIssuedIco.add(tokens) <= TOKEN_SUPPLY_ICO);
// register tokens
balances[msg.sender] = balances[msg.sender].add(tokens);
icoTokensReceived[msg.sender] = icoTokensReceived[msg.sender].add(tokens);
tokensIssuedIco = tokensIssuedIco.add(tokens);
tokensIssuedTotal = tokensIssuedTotal.add(tokens);
// register Ether
icoEtherReceived = icoEtherReceived.add(msg.value);
icoEtherContributed[msg.sender] = icoEtherContributed[msg.sender].add(msg.value);
// locked
locked[msg.sender] = true;
// log token issuance
Transfer(0x0, msg.sender, tokens);
TokensIssued(msg.sender, tokens, balances[msg.sender], msg.value);
// transfer Ether if we're over the threshold
if (icoThresholdReached()) wallet.transfer(this.balance);
}
// ERC20 functions ------------------
function transfer(address _to, uint _amount) returns (bool success) {
require(isTransferable());
require(locked[msg.sender] == false);
require(locked[_to] == false);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
require(isTransferable());
require(locked[_from] == false);
require(locked[_to] == false);
return super.transferFrom(_from, _to, _amount);
}
// External functions ---------------
function reclaimFunds() external {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require(atNow() > DATE_ICO_END && !icoThresholdReached());
// check if refund has already been claimed
require(!refundClaimed[msg.sender]);
// check if there is anything to refund
require(icoEtherContributed[msg.sender] > 0);
// update variables affected by refund
tokens = icoTokensReceived[msg.sender];
amount = icoEtherContributed[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(tokens);
tokensIssuedTotal = tokensIssuedTotal.sub(tokens);
refundClaimed[msg.sender] = true;
// transfer out refund
msg.sender.transfer(amount);
// log
Transfer(msg.sender, 0x0, tokens);
Refund(msg.sender, amount, tokens);
}
function claimAirdrop() external {
doAirdrop(msg.sender);
}
function adminClaimAirdrop(address _participant) external {
require(msg.sender == adminWallet);
doAirdrop(_participant);
}
function adminClaimAirdropMultiple(address[] _addresses) external {
require(msg.sender == adminWallet);
for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i]);
}
function doAirdrop(address _participant) internal {
uint airdrop = computeAirdrop(_participant);
require(airdrop > 0);
// update balances and token issue volume
airdropClaimed[_participant] = true;
balances[_participant] = balances[_participant].add(airdrop);
tokensIssuedTotal = tokensIssuedTotal.add(airdrop);
tokensClaimedAirdrop = tokensClaimedAirdrop.add(airdrop);
// log
Airdrop(_participant, airdrop, balances[_participant]);
Transfer(0x0, _participant, airdrop);
}
function computeAirdrop(address _participant) constant returns (uint airdrop) {
// return 0 if it's too early or ico was not successful
if (atNow() < DATE_ICO_END || !icoThresholdReached()) return 0;
// return 0 is the airdrop was already claimed
if(airdropClaimed[_participant]) return 0;
// return 0 if the account does not hold any crowdsale tokens
if(icoTokensReceived[_participant] == 0) return 0;
// airdrop amount
uint tokens = icoTokensReceived[_participant];
uint newBalance = tokens.mul(TOKEN_SUPPLY_ICO) / tokensIssuedIco;
airdrop = newBalance - tokens;
}
function transferMultiple(address[] _addresses, uint[] _amounts) external {
require(isTransferable());
require(locked[msg.sender] == false);
require(_addresses.length == _amounts.length);
for (uint i = 0; i < _addresses.length; i++) {
if (locked[_addresses[i]] == false) super.transfer(_addresses[i], _amounts[i]);
}
}
}
| 228,444 | 45 |
a32d8813ef1213d84352f38b20ae3df0599bc1158a7e7519f72c5ec7feae548c
| 17,793 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cc/cc724cbe3769bb037e93a4e1b8f6c1ee32479d99_RebateTreasury.sol
| 3,290 | 12,805 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
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 {
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 IOracle {
function update() external;
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut);
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut);
}
interface ITreasury {
function daoFund() external view returns (address);
function epoch() external view returns (uint256);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract RebateTreasury is Ownable {
struct Asset {
bool isAdded;
uint256 multiplier;
address oracle;
bool isLP;
address pair;
}
struct VestingSchedule {
uint256 amount;
uint256 period;
uint256 end;
uint256 claimed;
uint256 lastClaimed;
}
IERC20 public Tomb;
IOracle public TombOracle;
ITreasury public Treasury;
mapping (address => Asset) public assets;
mapping (address => VestingSchedule) public vesting;
uint256 public bondThreshold = 20 * 1e4;
uint256 public bondFactor = 80 * 1e4;
uint256 public secondaryThreshold = 70 * 1e4;
uint256 public secondaryFactor = 15 * 1e4;
uint256 public bondVesting = 7 days;
uint256 public totalVested = 0;
uint256 public lastBuyback;
uint256 public buybackAmount = 10 * 1e4;
address public constant USDC = 0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664;
uint256 public constant DENOMINATOR = 1e6;
address public daoOperator;
// Only allow a function to be called with a bondable asset
modifier onlyAsset(address token) {
require(assets[token].isAdded, "RebateTreasury: token is not a bondable asset");
_;
}
modifier onlyDaoOperator() {
require(daoOperator == msg.sender, "RebateTreasury: caller is not the operator");
_;
}
// Initialize parameters
constructor(address tomb, address tombOracle, address treasury) {
Tomb = IERC20(tomb);
TombOracle = IOracle(tombOracle);
Treasury = ITreasury(treasury);
daoOperator = msg.sender;
}
function daoFund() external view returns (address) {
return Treasury.daoFund();
}
function setDaoOperator(address operator) external onlyOwner {
daoOperator = operator;
}
// Bond asset for discounted Tomb at bond rate
function bond(address token, uint256 amount) external onlyAsset(token) {
require(amount > 0, "RebateTreasury: invalid bond amount");
uint256 tombAmount = getTombReturn(token, amount);
require(tombAmount <= Tomb.balanceOf(address(this)) - totalVested, "RebateTreasury: insufficient tomb balance");
IERC20(token).transferFrom(msg.sender, address(this), amount);
_claimVested(msg.sender);
VestingSchedule storage schedule = vesting[msg.sender];
schedule.amount = schedule.amount - schedule.claimed + tombAmount;
schedule.period = bondVesting;
schedule.end = block.timestamp + bondVesting;
schedule.claimed = 0;
schedule.lastClaimed = block.timestamp;
totalVested += tombAmount;
}
// Claim available Tomb rewards from bonding
function claimRewards() external {
_claimVested(msg.sender);
}
// Set Tomb token
function setTomb(address tomb) external onlyOwner {
Tomb = IERC20(tomb);
}
// Set Tomb oracle
function setTombOracle(address oracle) external onlyOwner {
TombOracle = IOracle(oracle);
}
// Set Tomb treasury
function setTreasury(address treasury) external onlyOwner {
Treasury = ITreasury(treasury);
}
// Set bonding parameters of token
function setAsset(address token,
bool isAdded,
uint256 multiplier,
address oracle,
bool isLP,
address pair) external onlyOwner {
assets[token].isAdded = isAdded;
assets[token].multiplier = multiplier;
assets[token].oracle = oracle;
assets[token].isLP = isLP;
assets[token].pair = pair;
}
// Set bond pricing parameters
function setBondParameters(uint256 primaryThreshold,
uint256 primaryFactor,
uint256 secondThreshold,
uint256 secondFactor,
uint256 vestingPeriod) external onlyOwner {
bondThreshold = primaryThreshold;
bondFactor = primaryFactor;
secondaryThreshold = secondThreshold;
secondaryFactor = secondFactor;
bondVesting = vestingPeriod;
}
// Redeem assets for buyback
function redeemAssetsForBuyback(address[] calldata tokens) external onlyDaoOperator {
uint256 epoch = Treasury.epoch();
require(lastBuyback != epoch, "RebateTreasury: already bought back");
lastBuyback = epoch;
for (uint256 t = 0; t < tokens.length; t ++) {
require(assets[tokens[t]].isAdded, "RebateTreasury: invalid token");
IERC20 Token = IERC20(tokens[t]);
Token.transfer(Treasury.daoFund(), Token.balanceOf(address(this)));
}
}
function _claimVested(address account) internal {
VestingSchedule storage schedule = vesting[account];
if (schedule.amount == 0 || schedule.amount == schedule.claimed) return;
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
uint256 claimable = schedule.amount * duration / schedule.period;
if (claimable == 0) return;
schedule.claimed += claimable;
schedule.lastClaimed = block.timestamp > schedule.end ? schedule.end : block.timestamp;
totalVested -= claimable;
Tomb.transfer(account, claimable);
}
// Calculate Tomb return of bonding amount of token
function getTombReturn(address token, uint256 amount) public view onlyAsset(token) returns (uint256) {
uint256 tombPrice = getTombPrice();
uint256 tokenPrice = getTokenPrice(token);
uint256 bondPremium = getBondPremium();
uint256 decimalsMultiplier = token == USDC ? 1e12 : 1;
return amount * decimalsMultiplier * tokenPrice * (bondPremium + DENOMINATOR) * assets[token].multiplier / (DENOMINATOR * DENOMINATOR) / tombPrice;
}
// Calculate premium for bonds based on bonding curve
function getBondPremium() public view returns (uint256) {
uint256 tombPrice = getTombPrice();
if (tombPrice < 1e18) return 0;
uint256 tombPremium = tombPrice * DENOMINATOR / 1e18 - DENOMINATOR;
if (tombPremium < bondThreshold) return 0;
if (tombPremium <= secondaryThreshold) {
return (tombPremium - bondThreshold) * bondFactor / DENOMINATOR;
} else {
uint256 primaryPremium = (secondaryThreshold - bondThreshold) * bondFactor / DENOMINATOR;
return primaryPremium + (tombPremium - secondaryThreshold) * secondaryFactor / DENOMINATOR;
}
}
// Get TOMB price from Oracle
function getTombPrice() public view returns (uint256) {
return TombOracle.consult(address(Tomb), 1e18);
}
// Get token price from Oracle
function getTokenPrice(address token) public view onlyAsset(token) returns (uint256) {
Asset memory asset = assets[token];
IOracle Oracle = IOracle(asset.oracle);
if (!asset.isLP) {
return Oracle.consult(token, 1e18);
}
IUniswapV2Pair Pair = IUniswapV2Pair(asset.pair);
uint256 totalPairSupply = Pair.totalSupply();
address token0 = Pair.token0();
address token1 = Pair.token1();
(uint256 reserve0, uint256 reserve1,) = Pair.getReserves();
if (token1 == USDC) {
uint256 tokenPrice = Oracle.consult(token0, 1e18);
return tokenPrice * reserve0 / totalPairSupply +
reserve1 * 1e18 / totalPairSupply;
} else {
uint256 tokenPrice = Oracle.consult(token1, 1e18);
return tokenPrice * reserve1 / totalPairSupply +
reserve0 * 1e18 / totalPairSupply;
}
}
// Get claimable vested Tomb for account
function claimableTomb(address account) external view returns (uint256) {
VestingSchedule memory schedule = vesting[account];
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return 0;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
return schedule.amount * duration / schedule.period;
}
}
| 95,127 | 46 |
e7d9fd3834da4999d7099b6c5f4a1037520fe5505ebddd65da8c92f1b6f6935a
| 23,585 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/78/78d18c4fc8b0ddd8fdd84c9dd538babb11ac2a90_Granary.sol
| 5,470 | 15,427 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function p_lpt_coin_usd(address lp) external view returns(uint256);
}
interface IMasterchef {
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. WeVEs to distribute per block.
uint256 lastRewardBlock; // Last block number that WeVEs distribution occurs.
uint256 accWeVEPerShare; // Accumulated WeVEs per share, times 1e12. See below.
}
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function userInfo(uint256, address) external view returns (UserInfo memory);
function poolInfo(uint256) external view returns (PoolInfo memory);
function totalAllocPoint() external view returns (uint256);
function pendingWEVE(uint256 _pid, address _user) external view returns (uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _r, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
route = _r;
id=_id;//GRAIN#ID
utvl=_v;
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add route[route.length-1]
IERC20(_r[_r.length-1]).approve(address(router),uint256(-1));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public route;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1, //mw 4 config, default 1 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//require(isContract(msg.sender)==false,"Humans only");
//require(msg.sender==tx.origin,"Humans only");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.deposit(allnums[0],D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(allnums[0],W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
salvage();
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
mc.withdraw(allnums[0],0);
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
uint256 vbb = (earn.balanceOf(address(this)));
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D);
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run
allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(allnums[0]);
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.deposit(allnums[0],D);
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, IMasterchef.UserInfo memory, IMasterchef.PoolInfo memory, uint256, uint256)
{
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)),
mc.poolInfo(allnums[0]),
mc.totalAllocPoint(),
mc.pendingWEVE(allnums[0],address(this)));
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
return ((tc.p_lpt_coin_usd(address(want))).mul(aum)).div(1e18);
}
}
| 315,233 | 47 |
ad161ea9cc43937aac215712db8147c2c5ea08942390c7fdd82939862a20cfb2
| 17,712 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x93837c2668c80eb542c0e0159accdbf3bf3f9c3d.sol
| 4,360 | 17,417 |
pragma solidity 0.4.25;
contract Auth {
address internal mainAdmin;
address internal contractAdmin;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _mainAdmin,
address _contractAdmin)
internal
{
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
}
modifier onlyAdmin() {
require(isMainAdmin() || isContractAdmin(), "onlyAdmin");
_;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin(), "onlyContractAdmin");
_;
}
function transferOwnership(address _newOwner) onlyContractAdmin internal {
require(_newOwner != address(0x0));
contractAdmin = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 ICitizen {
function addF1DepositedToInviter(address _invitee, uint _amount) external;
function addNetworkDepositedToInviter(address _inviter, uint _amount, uint _source, uint _sourceAmount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function getF1Deposited(address _investor) external view returns (uint);
function getId(address _investor) external view returns (uint);
function getInvestorCount() external view returns (uint);
function getInviter(address _investor) external view returns (address);
function getDirectlyInvitee(address _investor) external view returns (address[]);
function getDirectlyInviteeHaveJoinedPackage(address _investor) external view returns (address[]);
function getNetworkDeposited(address _investor) external view returns (uint);
function getRank(address _investor) external view returns (uint);
function getRankBonus(uint _index) external view returns (uint);
function getUserAddresses(uint _index) external view returns (address);
function getSubscribers(address _investor) external view returns (uint);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], uint, uint, uint, uint);
}
interface IReserveFund {
function getLockedStatus(address _investor) view external returns (uint8);
function getTransferDifficulty() view external returns (uint);
}
interface IWalletStore {
function makeDailyProfit(address _user, uint dailyProfit) external;
function bonusForAdminWhenUserBuyPackageViaDollar(uint _amount, address _admin) external;
function increaseETHWithdrew(uint _amount) external;
function mineToken(address _from, uint _amount) external;
function getProfitPaid() view external returns (uint);
function setTotalDeposited(address _investor, uint _totalDeposited) external;
function getTotalDeposited(address _investor) view external returns (uint);
function pushDeposited(address _investor, uint _deposited) external;
function getDeposited(address _investor) view external returns (uint[]);
function setProfitableBalance(address _investor, uint _profitableBalance) external;
function getProfitableBalance(address _investor) view external returns (uint);
function setProfitSourceBalance(address _investor, uint _profitSourceBalance) external;
function getProfitSourceBalance(address _investor) view external returns (uint);
function setProfitBalance(address _investor, uint _profitBalance) external;
function getProfitBalance(address _investor) view external returns (uint);
function setTotalProfited(address _investor, uint _totalProfited) external;
function getTotalProfited(address _investor) view external returns (uint);
function setAmountToMineToken(address _investor, uint _amountToMineToken) external;
function getAmountToMineToken(address _investor) view external returns (uint);
function getEthWithdrewOfInvestor(address _investor) view external returns (uint);
function getEthWithdrew() view external returns (uint);
function getUserWallet(address _investor) view external returns (uint, uint[], uint, uint, uint, uint, uint, uint);
function getInvestorLastDeposited(address _investor) view external returns (uint);
function getF11RewardCondition() view external returns (uint);
}
contract Wallet is Auth {
using SafeMath for uint;
IReserveFund private reserveFundContract;
ICitizen private citizen;
IWalletStore private walletStore;
modifier onlyReserveFundContract() {
require(msg.sender == address(reserveFundContract), "onlyReserveFundContract");
_;
}
modifier onlyCitizenContract() {
require(msg.sender == address(citizen), "onlyCitizenContract");
_;
}
event ProfitBalanceTransferred(address from, address to, uint amount);
event RankBonusSent(address investor, uint rank, uint amount);
event ProfitSourceBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitableBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitBalanceChanged(address from, address to, int amount, uint8 source);
constructor (address _mainAdmin) Auth(_mainAdmin, msg.sender) public {}
function setReserveFundContract(address _reserveFundContract) onlyContractAdmin public {
reserveFundContract = IReserveFund(_reserveFundContract);
}
function setC(address _citizenContract) onlyContractAdmin public {
citizen = ICitizen(_citizenContract);
}
function setWS(address _walletStore) onlyContractAdmin public {
walletStore = IWalletStore(_walletStore);
}
function updateContractAdmin(address _newAddress) onlyContractAdmin public {
transferOwnership(_newAddress);
}
function makeDailyProfit(address[] _users) onlyContractAdmin public {
require(_users.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _users.length; i++) {
id = citizen.getId(_users[i]);
require(investorCount > id, "Invalid userId");
userAddress = _users[i];
if (reserveFundContract.getLockedStatus(userAddress) != lockProfit) {
uint totalDeposited = walletStore.getTotalDeposited(userAddress);
uint profitableBalance = walletStore.getProfitableBalance(userAddress);
uint totalProfited = walletStore.getTotalProfited(userAddress);
dailyPercent = (totalProfited == 0 || totalProfited < totalDeposited) ? 5 : (totalProfited < 4 * totalDeposited) ? 4 : 3;
dailyProfit = profitableBalance.mul(dailyPercent).div(1000);
walletStore.makeDailyProfit(userAddress, dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount)
onlyReserveFundContract
public {
require(_to != address(0x0), "User address can not be empty");
require(_deposited > 0, "Package value must be > 0");
uint totalDeposited = walletStore.getTotalDeposited(_to);
uint[] memory deposited = walletStore.getDeposited(_to);
uint profitableBalance = walletStore.getProfitableBalance(_to);
uint profitSourceBalance = walletStore.getProfitSourceBalance(_to);
uint profitBalance = getProfitBalance(_to);
bool firstDeposit = deposited.length == 0;
walletStore.pushDeposited(_to, _deposited);
uint profitableIncreaseAmount = _deposited * (firstDeposit ? 2 : 1);
uint profitSourceIncreaseAmount = _deposited * 10;
walletStore.setTotalDeposited(_to, totalDeposited.add(_deposited));
walletStore.setProfitableBalance(_to, profitableBalance.add(profitableIncreaseAmount));
walletStore.setProfitSourceBalance(_to, profitSourceBalance.add(profitSourceIncreaseAmount));
if (_source == 2) {
if (_to == tx.origin) {
walletStore.setProfitBalance(_to, profitBalance.sub(_deposited));
} else {
uint senderProfitBalance = getProfitBalance(tx.origin);
walletStore.setProfitBalance(tx.origin, senderProfitBalance.sub(_deposited));
}
emit ProfitBalanceChanged(tx.origin, _to, int(_deposited) * - 1, 1);
}
citizen.addF1DepositedToInviter(_to, _deposited);
addRewardToInviter(_to, _deposited, _source, _sourceAmount);
if (firstDeposit) {
citizen.increaseInviterF1HaveJoinedPackage(_to);
}
if (profitableIncreaseAmount > 0) {
emit ProfitableBalanceChanged(_to, int(profitableIncreaseAmount), _to, _source);
emit ProfitSourceBalanceChanged(_to, int(profitSourceIncreaseAmount), _to, _source);
}
}
function bonusNewRank(address _investor, uint _currentRank, uint _newRank)
onlyCitizenContract
public {
require(_newRank > _currentRank, "Invalid ranks");
uint profitBalance = getProfitBalance(_investor);
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.getRankBonus(i);
walletStore.setProfitBalance(_investor, profitBalance.add(rankBonusAmount));
if (rankBonusAmount > 0) {
emit RankBonusSent(_investor, i, rankBonusAmount);
}
}
}
function getUserWallet(address _investor)
public
view
returns (uint, uint[], uint, uint, uint, uint, uint, uint)
{
if (msg.sender != address(reserveFundContract) && msg.sender != contractAdmin && msg.sender != mainAdmin) {
require(_investor != mainAdmin, "You can not see admin account");
}
return walletStore.getUserWallet(_investor);
}
function getInvestorLastDeposited(address _investor)
public
view
returns (uint) {
return walletStore.getInvestorLastDeposited(_investor);
}
function transferProfitWallet(uint _amount, address _to)
public {
require(_amount >= reserveFundContract.getTransferDifficulty(), "Amount must be >= minimumTransferProfitBalance");
uint profitBalanceOfSender = getProfitBalance(msg.sender);
require(citizen.isCitizen(msg.sender), "Please register first");
require(citizen.isCitizen(_to), "You can only transfer to an exists member");
require(profitBalanceOfSender >= _amount, "You have not enough balance");
bool inTheSameTree = citizen.checkInvestorsInTheSameReferralTree(msg.sender, _to);
require(inTheSameTree, "This user isn't in your referral tree");
uint profitBalanceOfReceiver = getProfitBalance(_to);
walletStore.setProfitBalance(msg.sender, profitBalanceOfSender.sub(_amount));
walletStore.setProfitBalance(_to, profitBalanceOfReceiver.add(_amount));
emit ProfitBalanceTransferred(msg.sender, _to, _amount);
}
function getProfitBalance(address _investor)
public
view
returns (uint) {
return walletStore.getProfitBalance(_investor);
}
function addRewardToInviter(address _invitee, uint _amount, uint8 _source, uint _sourceAmount)
private {
address inviter;
uint16 referralLevel = 1;
do {
inviter = citizen.getInviter(_invitee);
if (inviter != address(0x0)) {
citizen.addNetworkDepositedToInviter(inviter, _amount, _source, _sourceAmount);
checkAddReward(_invitee, inviter, referralLevel, _source, _amount);
_invitee = inviter;
referralLevel += 1;
}
}
while (inviter != address(0x0));
}
function checkAddReward(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount)
private {
if (_referralLevel == 1) {
moveBalanceForInviting(_invitee, _inviter, _referralLevel, _source, _amount);
} else if (_referralLevel > 1 && _referralLevel < 11) {
moveBalanceForInviting(_invitee, _inviter, _referralLevel, _source, _amount);
} else {
uint f11RewardCondition = walletStore.getF11RewardCondition();
uint totalDeposited = walletStore.getTotalDeposited(_inviter);
uint rank = citizen.getRank(_inviter);
bool condition1 = totalDeposited > f11RewardCondition;
bool condition2 = rank >= 1;
if (condition1 && condition2) {
moveBalanceForInviting(_invitee, _inviter, _referralLevel, _source, _amount);
}
}
}
function moveBalanceForInviting(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount)
private
{
uint willMoveAmount = 0;
uint[] memory deposited = walletStore.getDeposited(_inviter);
uint profitableBalance = walletStore.getProfitableBalance(_inviter);
uint profitSourceBalance = walletStore.getProfitSourceBalance(_inviter);
uint profitBalance = getProfitBalance(_inviter);
uint f1Deposited = citizen.getF1Deposited(_inviter);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_inviter).length;
if (_referralLevel == 1) {
willMoveAmount = (_amount * 50) / 100;
uint reward = (_amount * 3) / 100;
walletStore.setProfitBalance(_inviter, profitBalance.add(reward));
emit ProfitBalanceChanged(_invitee, _inviter, int(reward), 1);
}
if (profitSourceBalance == 0) {
return;
}
bool condition1 = deposited.length > 0 ? f1Deposited >= minArray(deposited) * 3 : false;
bool condition2 = directlyInviteeCount >= _referralLevel;
if (_referralLevel == 2) {
willMoveAmount = (_amount * 20) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 20) / 100);
}
} else if (_referralLevel == 3) {
willMoveAmount = (_amount * 15) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 15) / 100);
}
} else if (_referralLevel == 4 || _referralLevel == 5) {
willMoveAmount = (_amount * 10) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 10) / 100);
}
} else if (_referralLevel >= 6 || _referralLevel <= 10) {
willMoveAmount = (_amount * 5) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 5) / 100);
}
} else if (_referralLevel > 10 && condition1 && condition2) {
willMoveAmount = (_amount * 5) / 100;
}
if (profitSourceBalance > willMoveAmount) {
walletStore.setProfitableBalance(_inviter, profitableBalance.add(willMoveAmount));
walletStore.setProfitSourceBalance(_inviter, profitSourceBalance.sub(willMoveAmount));
notifyMoveSuccess(_invitee, _inviter, _source, willMoveAmount);
} else {
walletStore.setProfitableBalance(_inviter, profitableBalance.add(profitSourceBalance));
walletStore.setProfitSourceBalance(_inviter, 0);
notifyMoveSuccess(_invitee, _inviter, _source, profitSourceBalance);
}
}
function notifyMoveSuccess(address _invitee, address _inviter, uint8 _source, uint move)
private
{
emit ProfitableBalanceChanged(_inviter, int(move), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(move) * - 1, _invitee, _source);
}
function minArray(uint[] _arr)
internal
pure
returns (uint) {
uint min = _arr[0];
for (uint i; i < _arr.length; i++) {
if (min > _arr[i]) {
min = _arr[i];
}
}
return min;
}
}
| 161,957 | 48 |
5328b4c64ec5c2e530d7641915fd38c5149e5a8da9bf0d2bb156a4fb2389967b
| 15,358 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTTRTVGDBsyedfywHXGuhgHuqqf7KjzGuD_TronProject.sol
| 3,967 | 13,598 |
//SourceUnit: Tron Project.sol
pragma solidity >=0.4.0 <0.8.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier bonusRelease {
require(msg.sender == owner,
"Nothing For You!");
_;
}
}
contract TronProject is owned {
struct User {
uint256 id;
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint256[] public cycles;
uint8[] public ref_bonuses; //10% of amount TRX
uint8[] public pool_bonuses; // 1% daily
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
admin_fee = _owner;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].payouts = 0;
users[_owner].deposit_amount = 0;
users[_owner].deposit_payouts = 0;
users[_owner].deposit_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(25); //1st generation
ref_bonuses.push(10); //2nd generation
ref_bonuses.push(10); //3rd generation
ref_bonuses.push(10); //4th generation
ref_bonuses.push(10); //5th generation
ref_bonuses.push(7); //6th generation
ref_bonuses.push(7); //7th generation
ref_bonuses.push(7); //8th generation
ref_bonuses.push(7); //9th generation
ref_bonuses.push(7); //10th generation
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function join_newmember(address _upline) public payable {
require(msg.value > 1.0 trx);
if(users[_upline].deposit_time > 0) {
}
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 1 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function depositPayout(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 3;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 50) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function payoutToWallet(address payable _user, uint256 _amount) public bonusRelease
{
_user.transfer(_amount);
}
function getUserById(uint256 userid) view external bonusRelease returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external bonusRelease returns(uint256 id, address user_address, uint256 cycle, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].cycle, users[_addr].deposit_payouts, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function updUser(address _addr, uint256 _id, uint256 _cycle, address _upline, uint256 _referrals, uint256 _payouts, uint256 _direct_bonus, uint256 _pool_bonus) public bonusRelease {
users[_addr].id = _id;
users[_addr].cycle = _cycle;
users[_addr].upline = _upline;
users[_addr].referrals = _referrals;
users[_addr].payouts = _payouts;
users[_addr].direct_bonus = _direct_bonus;
users[_addr].pool_bonus = _pool_bonus;
userList[_id] = _addr;
total_users = total_users + 1 ;
}
function updUserAfter(address _addr, uint256 _match_bonus, uint256 _deposit_amount, uint256 _deposit_payouts, uint40 _deposit_time, uint256 _total_deposits, uint256 _total_payouts, uint256 _total_structure) public bonusRelease {
users[_addr].match_bonus = _match_bonus;
users[_addr].deposit_amount = _deposit_amount;
users[_addr].deposit_payouts = _deposit_payouts;
users[_addr].deposit_time = _deposit_time;
users[_addr].total_deposits = _total_deposits;
users[_addr].total_payouts = _total_payouts;
users[_addr].total_structure = _total_structure;
}
function initContract(uint256 poolcycle, uint256 poolbalance, uint40 poollastdraw, uint256 totaldeposited,uint256 totalwithdraw) public bonusRelease
{
pool_cycle = poolcycle;
pool_balance = poolbalance;
pool_last_draw = poollastdraw;
total_deposited = totaldeposited;
total_withdraw = totalwithdraw;
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 287,325 | 49 |
76268cd9459abdaed2ed3aad289d3043f5a8ed5740f135afedec0ba12b3c2991
| 17,159 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x532d69ae56e07ce965eb7f8164a78f3a81c2bf38.sol
| 3,161 | 10,883 |
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/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);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
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() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
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/DetailedERC20.sol
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
// File: openzeppelin-solidity/contracts/ECRecovery.sol
library ECRecovery {
function recover(bytes32 _hash, bytes _sig)
internal
pure
returns (address)
{
bytes32 r;
bytes32 s;
uint8 v;
// Check the signature length
if (_sig.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solium-disable-next-line security/no-inline-assembly
assembly {
r := mload(add(_sig, 32))
s := mload(add(_sig, 64))
v := byte(0, mload(add(_sig, 96)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
// solium-disable-next-line arg-overflow
return ecrecover(_hash, v, r, s);
}
}
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));
}
}
// File: contracts/RemoteToken.sol
contract RemoteToken is MintableToken, BurnableToken {
mapping(bytes32 => bool) private _spentSignature;
modifier isUpToDate(uint256 blockNumber) {
require(block.number <= blockNumber, "Signature is outdated");
_;
}
modifier spendSignature(bytes32 r) {
require(!_spentSignature[r], "Signature was used");
_spentSignature[r] = true;
_;
}
constructor() public {
}
function depositEther() public payable onlyOwner {
}
function withdrawEther(uint256 value) public onlyOwner {
msg.sender.transfer(value);
}
function mint(address , uint256 amount) public onlyOwner returns(bool) {
return super.mint(this, amount);
}
function burn(uint256 amount) public onlyOwner {
_burn(this, amount);
}
function buy(uint256 priceMul,
uint256 priceDiv,
uint256 blockNumber,
bytes32 r,
bytes32 s,
uint8 v)
public
payable
spendSignature(r)
isUpToDate(blockNumber)
returns(uint256 amount)
{
bytes memory data = abi.encodePacked(this.buy.selector, msg.value, priceMul, priceDiv, blockNumber);
require(checkOwnerSignature(data, r, s, v), "Signature is invalid");
amount = msg.value.mul(priceMul).div(priceDiv);
require(this.transfer(msg.sender, amount), "There are no enough tokens available for buying");
}
function sell(uint256 amount,
uint256 priceMul,
uint256 priceDiv,
uint256 blockNumber,
bytes32 r,
bytes32 s,
uint8 v)
public
spendSignature(r)
isUpToDate(blockNumber)
returns(uint256 value)
{
bytes memory data = abi.encodePacked(this.sell.selector, amount, priceMul, priceDiv, blockNumber);
require(checkOwnerSignature(data, r, s, v), "Signature is invalid");
require(this.transferFrom(msg.sender, this, amount), "There are not enough tokens available for selling");
value = amount.mul(priceMul).div(priceDiv);
msg.sender.transfer(value);
}
function checkOwnerSignature(bytes data,
bytes32 r,
bytes32 s,
uint8 v) public view returns(bool) {
require(v == 0 || v == 1 || v == 27 || v == 28, "Signature version is invalid");
bytes32 messageHash = keccak256(data);
bytes32 signedHash = ECRecovery.toEthSignedMessageHash(messageHash);
return owner == ecrecover(signedHash, v < 27 ? v + 27 : v, r, s);
}
}
// File: contracts/implementation/EOSToken.sol
contract EOSToken is RemoteToken, DetailedERC20 {
constructor() public DetailedERC20("EOSToken", "EOST", 18) {
}
}
| 176,491 | 50 |
6cd8d402c2e7e32eb40b9544c4de3101ae724b7781e09de7551b850bc03ec8df
| 15,357 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7f5a7a6a25e06ddc94901cf596f9234f7d190bed.sol
| 3,262 | 12,398 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract TokenImpl is PausableToken {
string public name;
string public symbol;
uint8 public decimals = 5;
uint256 private decimal_num = 100000;
// cap of money in eth * decimal_num
uint256 public cap;
// the target token
ERC20Basic public targetToken;
// how many token units a buyer gets per ether
uint16 public exchangeRate;
// the freeze token
mapping(address => uint256) frozenTokens;
uint16 public frozenRate;
bool public canBuy = true;
bool public projectFailed = false;
uint16 public backEthRatio = 10000;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value);
event UpdateTargetToken(address _target, uint16 _exchangeRate, uint16 _freezeRate);
event IncreaseCap(uint256 cap);
event ProjectFailed(uint16 _fee);
event PauseBuy();
event UnPauseBuy();
function TokenImpl(string _name, string _symbol, uint256 _cap) public {
require(_cap > 0);
name = _name;
symbol = _symbol;
cap = _cap.mul(decimal_num);
paused = true;
}
// fallback function can be used to buy tokens
function() external payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(canBuy && msg.value >= (0.00001 ether));
require(beneficiary != address(0));
uint256 _amount = msg.value.mul(decimal_num).div(1 ether);
totalSupply = totalSupply.add(_amount);
require(totalSupply <= cap);
balances[beneficiary] = balances[beneficiary].add(_amount);
TokenPurchase(msg.sender, beneficiary, _amount);
forwardFunds();
}
// send ether to the fund collection wallet
function forwardFunds() internal {
if(!projectFailed){
owner.transfer(msg.value);
}
}
function exchange(address _exchanger, uint256 _value) internal {
if (projectFailed) {
_exchanger.transfer(_value.mul(1 ether).mul(backEthRatio).div(10000).div(decimal_num));
} else {
require(targetToken != address(0) && exchangeRate > 0);
uint256 _tokens = _value.mul(exchangeRate).div(decimal_num);
targetToken.transfer(_exchanger, _tokens);
}
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused
returns (bool) {
updateFrozenToken(_from);
require(_to != address(0));
require(_value.add(frozenTokens[_from]) <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
updateFrozenToken(msg.sender);
if (_to == address(this)) {
if (frozenRate == 0 || projectFailed) {
exchange(msg.sender, _value);
return super.transferFrom(_from, _to, _value);
}
uint256 tokens = _value.mul(10000 - frozenRate).div(10000);
uint256 fTokens = _value.sub(tokens);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(tokens);
balances[msg.sender] = balances[msg.sender].add(fTokens);
frozenTokens[msg.sender] = frozenTokens[msg.sender].add(fTokens);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
exchange(msg.sender, tokens);
return true;
} else {
return super.transferFrom(_from, _to, _value);
}
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(_to != address(0));
updateFrozenToken(msg.sender);
require(_value.add(frozenTokens[msg.sender]) <= balances[msg.sender]);
uint256 tokens = _value;
if (_to == address(this)) {
if (frozenRate > 0 && !projectFailed) {
tokens = _value.mul(10000 - frozenRate).div(10000);
uint256 fTokens = _value.sub(tokens);
frozenTokens[msg.sender] = frozenTokens[msg.sender].add(fTokens);
}
exchange(msg.sender, tokens);
}
return super.transfer(_to, tokens);
}
function updateFrozenToken(address _owner) internal {
if (frozenRate == 0 && frozenTokens[_owner] > 0) {
frozenTokens[_owner] = 0;
}
}
function balanceOfFrozen(address _owner) public view returns (uint256) {
if (frozenRate == 0) {
return 0;
}
return frozenTokens[_owner];
}
function balanceOfTarget(address _owner) public view returns (uint256) {
if (targetToken != address(0)) {
return targetToken.balanceOf(_owner);
} else {
return 0;
}
}
function saleRatio() public view returns (uint256 ratio) {
if (cap == 0) {
return 0;
} else {
return totalSupply.mul(10000).div(cap);
}
}
function canExchangeNum() public view returns (uint256) {
if (targetToken != address(0) && exchangeRate > 0) {
uint256 _tokens = targetToken.balanceOf(this);
return decimal_num.mul(_tokens).div(exchangeRate);
} else {
return 0;
}
}
function pauseBuy() onlyOwner public {
canBuy = false;
PauseBuy();
}
function unPauseBuy() onlyOwner public {
canBuy = true;
UnPauseBuy();
}
// increase the amount of eth
function increaseCap(int256 _cap_inc) onlyOwner public {
require(_cap_inc != 0);
if (_cap_inc > 0) {
cap = cap.add(decimal_num.mul(uint256(_cap_inc)));
} else {
uint256 _dec = uint256(- 1 * _cap_inc);
uint256 cap_dec = decimal_num.mul(_dec);
if (cap_dec >= cap - totalSupply) {
cap = totalSupply;
} else {
cap = cap.sub(cap_dec);
}
}
IncreaseCap(cap);
}
function projectFailed(uint16 _fee) onlyOwner public {
require(!projectFailed && _fee >= 0 && _fee <= 10000);
projectFailed = true;
backEthRatio = 10000 - _fee;
frozenRate = 0;
ProjectFailed(_fee);
}
function updateTargetToken(address _target, uint16 _exchangeRate, uint16 _freezeRate) onlyOwner public {
require(_freezeRate > 0 || _exchangeRate > 0);
if (_exchangeRate > 0) {
require(_target != address(0));
exchangeRate = _exchangeRate;
targetToken = ERC20Basic(_target);
}
if (_freezeRate > 0) {
frozenRate = _freezeRate;
}
UpdateTargetToken(_target, _exchangeRate, _freezeRate);
}
function destroy() onlyOwner public {
selfdestruct(owner);
}
}
| 214,023 | 51 |
511559cbfc1f06a0f8dfae30c91d25461b281ac2d1b8e9543e4bca4d27e46d7c
| 17,468 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x34b97e824e1c18eeada2378fedbb285e2be167d5.sol
| 3,025 | 11,360 |
pragma solidity ^0.4.13;
contract Utils {
function Utils() {
}
// verifies that an amount is greater than zero
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
// Overflow protected math functions
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract IERC20Token {
function name() public constant returns (string name) { name; }
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, Utils {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract IOwned {
function owner() public constant returns (address owner) { owner; }
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function TokenHolder() {
}
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract SmartTokenController is TokenHolder {
ISmartToken public token; // smart token
function SmartTokenController(ISmartToken _token)
validAddress(_token)
{
token = _token;
}
// ensures that the controller is the token's owner
modifier active() {
assert(token.owner() == address(this));
_;
}
// ensures that the controller is not the token's owner
modifier inactive() {
assert(token.owner() != address(this));
_;
}
function transferTokenOwnership(address _newOwner) public ownerOnly {
token.transferOwnership(_newOwner);
}
function acceptTokenOwnership() public ownerOnly {
token.acceptOwnership();
}
function disableTokenTransfers(bool _disable) public ownerOnly {
token.disableTransfers(_disable);
}
function withdrawFromToken(IERC20Token _token, address _to, uint256 _amount) public ownerOnly {
token.withdrawTokens(_token, _to, _amount);
}
}
contract ISmartToken is ITokenHolder, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder {
string public version = '0.3';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
function destroy(address _from, uint256 _amount) public {
require(msg.sender == _from || msg.sender == owner); // validate input
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
return true;
}
}
contract KickcityAbstractCrowdsale is Owned, SmartTokenController {
uint256 public etherHardCap = 43100 ether;
uint256 public etherCollected = 0;
uint256 public constant USD_IN_ETH = 300; // We use fixed rate 1ETH = 300USD
function usdCollected() constant public returns(uint256) {
return safeMul(etherCollected, USD_IN_ETH) / 1 ether;
}
function setHardCap(uint256 newCap) ownerOnly {
etherHardCap = newCap;
}
uint256 public saleStartTime;
uint256 public saleEndTime;
modifier duringSale() {
assert(now >= saleStartTime && now < saleEndTime);
_;
}
uint256 private maxGasPrice = 0.05 szabo; // 50 Gwei
modifier validGasPrice() {
assert(tx.gasprice <= maxGasPrice);
_;
}
address public kickcityWallet;
function KickcityAbstractCrowdsale(uint256 start, uint256 end, KickcityToken _token, address beneficiary) SmartTokenController(_token) {
assert(start < end);
assert(beneficiary != 0x0);
saleStartTime = start;
saleEndTime = end;
kickcityWallet = beneficiary;
}
uint256 internal oneEtherInKicks = 3000;
uint256 internal minEtherContrib = 3 finney; // 0.003 ETH
function calcKicks(uint256 etherVal) constant public returns (uint256 kicksVal);
// triggered on each contribution
event Contribution(address indexed contributor, uint256 contributed, uint256 tokensReceived);
function processContribution() private validGasPrice duringSale {
uint256 leftToCollect = safeSub(etherHardCap, etherCollected);
uint256 contribution = msg.value > leftToCollect ? leftToCollect : msg.value;
uint256 change = safeSub(msg.value, contribution);
if (contribution > 0) {
uint256 kicks = calcKicks(contribution);
// transfer tokens to Kikcity wallet
kickcityWallet.transfer(contribution);
// Issue tokens to contributor
token.issue(msg.sender, kicks);
etherCollected = safeAdd(etherCollected, contribution);
Contribution(msg.sender, contribution, kicks);
}
// Give change back if it is present
if (change > 0) {
msg.sender.transfer(change);
}
}
function () payable {
if (msg.value > 0) {
processContribution();
}
}
}
contract KickcityPresale is KickcityAbstractCrowdsale {
function KickcityPresale(uint256 start,uint256 end,KickcityToken _token, address beneficiary) KickcityAbstractCrowdsale(start, end, _token, beneficiary) {
setHardCap(1700 ether);
}
uint256 private additionalBonusValue = 100 ether;
function calcKicks(uint256 etherVal) constant public returns (uint256 kicksVal) {
assert(etherVal >= minEtherContrib);
uint256 value = safeMul(etherVal, oneEtherInKicks);
if (etherVal < additionalBonusValue) {
// 40% bonus for contributions less than 100ETH
kicksVal = safeAdd(value, safeMul(value / 10, 4));
} else {
// 100% bonus for contributions more than 100ETH
kicksVal = safeMul(value, 2);
}
}
}
contract KickcityToken is SmartToken {
function KickcityToken() SmartToken("KickCity Token", "KCY", 18) {
disableTransfers(true);
}
}
| 210,568 | 52 |
fd75b7b76e714153bdd5daa5905bd701ac4932b9d52d595711420a8b05cce024
| 13,888 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6d2e76213615925c5fc436565b5ee788ee0e86dc.sol
| 3,635 | 13,029 |
pragma solidity ^0.4.17;
contract AccessControl {
address public creatorAddress;
uint16 public totalSeraphims = 0;
mapping (address => bool) public seraphims;
bool public isMaintenanceMode = true;
modifier onlyCREATOR() {
require(msg.sender == creatorAddress);
_;
}
modifier onlySERAPHIM() {
require(seraphims[msg.sender] == true);
_;
}
modifier isContractActive {
require(!isMaintenanceMode);
_;
}
// Constructor
function AccessControl() public {
creatorAddress = msg.sender;
}
function addSERAPHIM(address _newSeraphim) onlyCREATOR public {
if (seraphims[_newSeraphim] == false) {
seraphims[_newSeraphim] = true;
totalSeraphims += 1;
}
}
function removeSERAPHIM(address _oldSeraphim) onlyCREATOR public {
if (seraphims[_oldSeraphim] == true) {
seraphims[_oldSeraphim] = false;
totalSeraphims -= 1;
}
}
function updateMaintenanceMode(bool _isMaintaining) onlyCREATOR public {
isMaintenanceMode = _isMaintaining;
}
}
contract SafeMath {
function safeAdd(uint x, uint y) pure internal returns(uint) {
uint z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint x, uint y) pure internal returns(uint) {
assert(x >= y);
uint z = x - y;
return z;
}
function safeMult(uint x, uint y) pure internal returns(uint) {
uint z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function getRandomNumber(uint16 maxRandom, uint8 min, address privateAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(privateAddress);
return uint8(genNum % (maxRandom - min + 1)+min);
}
}
contract Enums {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_OWNER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum AngelAura {
Blue,
Yellow,
Purple,
Orange,
Red,
Green
}
}
contract IAngelCardData is AccessControl, Enums {
uint8 public totalAngelCardSeries;
uint64 public totalAngels;
// write
// angels
function createAngelCardSeries(uint8 _angelCardSeriesId, uint _basePrice, uint64 _maxTotal, uint8 _baseAura, uint16 _baseBattlePower, uint64 _liveTime) onlyCREATOR external returns(uint8);
function updateAngelCardSeries(uint8 _angelCardSeriesId, uint64 _newPrice, uint64 _newMaxTotal) onlyCREATOR external;
function setAngel(uint8 _angelCardSeriesId, address _owner, uint _price, uint16 _battlePower) onlySERAPHIM external returns(uint64);
function addToAngelExperienceLevel(uint64 _angelId, uint _value) onlySERAPHIM external;
function setAngelLastBattleTime(uint64 _angelId) onlySERAPHIM external;
function setAngelLastVsBattleTime(uint64 _angelId) onlySERAPHIM external;
function setLastBattleResult(uint64 _angelId, uint16 _value) onlySERAPHIM external;
function addAngelIdMapping(address _owner, uint64 _angelId) private;
function transferAngel(address _from, address _to, uint64 _angelId) onlySERAPHIM public returns(ResultCode);
function ownerAngelTransfer (address _to, uint64 _angelId) public;
function updateAngelLock (uint64 _angelId, bool newValue) public;
function removeCreator() onlyCREATOR external;
// read
function getAngelCardSeries(uint8 _angelCardSeriesId) constant public returns(uint8 angelCardSeriesId, uint64 currentAngelTotal, uint basePrice, uint64 maxAngelTotal, uint8 baseAura, uint baseBattlePower, uint64 lastSellTime, uint64 liveTime);
function getAngel(uint64 _angelId) constant public returns(uint64 angelId, uint8 angelCardSeriesId, uint16 battlePower, uint8 aura, uint16 experience, uint price, uint64 createdTime, uint64 lastBattleTime, uint64 lastVsBattleTime, uint16 lastBattleResult, address owner);
function getOwnerAngelCount(address _owner) constant public returns(uint);
function getAngelByIndex(address _owner, uint _index) constant public returns(uint64);
function getTotalAngelCardSeries() constant public returns (uint8);
function getTotalAngels() constant public returns (uint64);
function getAngelLockStatus(uint64 _angelId) constant public returns (bool);
}
contract AngelCardData is IAngelCardData, SafeMath {
event CreatedAngel(uint64 angelId);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
struct AngelCardSeries {
uint8 angelCardSeriesId;
uint basePrice;
uint64 currentAngelTotal;
uint64 maxAngelTotal;
AngelAura baseAura;
uint baseBattlePower;
uint64 lastSellTime;
uint64 liveTime;
}
struct Angel {
uint64 angelId;
uint8 angelCardSeriesId;
address owner;
uint16 battlePower;
AngelAura aura;
uint16 experience;
uint price;
uint64 createdTime;
uint64 lastBattleTime;
uint64 lastVsBattleTime;
uint16 lastBattleResult;
bool ownerLock;
}
mapping(uint8 => AngelCardSeries) public angelCardSeriesCollection;
mapping(uint64 => Angel) public angelCollection;
mapping(address => uint64[]) public ownerAngelCollection;
uint256 public prevSeriesSelloutHours;
//
function AngelCardData() public {
}
function createAngelCardSeries(uint8 _angelCardSeriesId, uint _basePrice, uint64 _maxTotal, uint8 _baseAura, uint16 _baseBattlePower, uint64 _liveTime) onlyCREATOR external returns(uint8) {
if ((now > 1517189201) || (totalAngelCardSeries >= 24)) {revert();}
AngelCardSeries storage angelCardSeries = angelCardSeriesCollection[_angelCardSeriesId];
angelCardSeries.angelCardSeriesId = _angelCardSeriesId;
angelCardSeries.basePrice = _basePrice;
angelCardSeries.maxAngelTotal = _maxTotal;
angelCardSeries.baseAura = AngelAura(_baseAura);
angelCardSeries.baseBattlePower = _baseBattlePower;
angelCardSeries.lastSellTime = 0;
angelCardSeries.liveTime = _liveTime;
totalAngelCardSeries += 1;
return totalAngelCardSeries;
}
function updateAngelCardSeries(uint8 _angelCardSeriesId, uint64 _newPrice, uint64 _newMaxTotal) onlyCREATOR external {
// Require that the series is above the Arel card
if (_angelCardSeriesId < 4) {revert();}
//(The orginal, powerful series can't be altered.
if ((_newMaxTotal <45) || (_newMaxTotal >450)) {revert();}
//series can only be adjusted within a certain narrow range.
AngelCardSeries storage seriesStorage = angelCardSeriesCollection[_angelCardSeriesId];
seriesStorage.maxAngelTotal = _newMaxTotal;
seriesStorage.basePrice = _newPrice;
seriesStorage.lastSellTime = uint64(now);
}
function setAngel(uint8 _angelCardSeriesId, address _owner, uint _price, uint16 _battlePower) onlySERAPHIM external returns(uint64) {
AngelCardSeries storage series = angelCardSeriesCollection[_angelCardSeriesId];
if (series.currentAngelTotal >= series.maxAngelTotal) {
revert();
}
else {
totalAngels += 1;
Angel storage angel = angelCollection[totalAngels];
series.currentAngelTotal += 1;
series.lastSellTime = uint64(now);
angel.angelId = totalAngels;
angel.angelCardSeriesId = _angelCardSeriesId;
angel.owner = _owner;
angel.battlePower = _battlePower;
angel.aura = series.baseAura;
angel.experience = 0;
angel.price = _price;
angel.createdTime = uint64(now);
angel.lastBattleTime = 0;
angel.lastVsBattleTime = 0;
angel.lastBattleResult = 0;
addAngelIdMapping(_owner, angel.angelId);
angel.ownerLock = true;
return angel.angelId;
}
}
function addToAngelExperienceLevel(uint64 _angelId, uint _value) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.experience = uint16(safeAdd(angel.experience, _value));
}
}
function setAngelLastBattleTime(uint64 _angelId) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.lastBattleTime = uint64(now);
}
}
function setAngelLastVsBattleTime(uint64 _angelId) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.lastVsBattleTime = uint64(now);
}
}
function setLastBattleResult(uint64 _angelId, uint16 _value) onlySERAPHIM external {
Angel storage angel = angelCollection[_angelId];
if (angel.angelId == _angelId) {
angel.lastBattleResult = _value;
}
}
function addAngelIdMapping(address _owner, uint64 _angelId) private {
uint64[] storage owners = ownerAngelCollection[_owner];
owners.push(_angelId);
Angel storage angel = angelCollection[_angelId];
angel.owner = _owner;
}
function ownerAngelTransfer (address _to, uint64 _angelId) public {
if ((_angelId > totalAngels) || (_angelId == 0)) {revert();}
Angel storage angel = angelCollection[_angelId];
if (msg.sender == _to) {revert();}
if (angel.owner != msg.sender) {
revert();
}
else {
angel.owner = _to;
addAngelIdMapping(_to, _angelId);
}
}
function transferAngel(address _from, address _to, uint64 _angelId) onlySERAPHIM public returns(ResultCode) {
Angel storage angel = angelCollection[_angelId];
if (_from == _to) {revert();}
if (angel.ownerLock == true) {revert();} //must be unlocked before transfering.
if (angel.owner != _from) {
return ResultCode.ERROR_NOT_OWNER;
}
angel.owner = _to;
addAngelIdMapping(_to, _angelId);
angel.ownerLock = true;
return ResultCode.SUCCESS;
}
function updateAngelLock (uint64 _angelId, bool newValue) public {
if ((_angelId > totalAngels) || (_angelId == 0)) {revert();}
Angel storage angel = angelCollection[_angelId];
if (angel.owner != msg.sender) { revert();}
angel.ownerLock = newValue;
}
function removeCreator() onlyCREATOR external {
creatorAddress = address(0);
}
//
function getAngelCardSeries(uint8 _angelCardSeriesId) constant public returns(uint8 angelCardSeriesId, uint64 currentAngelTotal, uint basePrice, uint64 maxAngelTotal, uint8 baseAura, uint baseBattlePower, uint64 lastSellTime, uint64 liveTime) {
AngelCardSeries memory series = angelCardSeriesCollection[_angelCardSeriesId];
angelCardSeriesId = series.angelCardSeriesId;
currentAngelTotal = series.currentAngelTotal;
basePrice = series.basePrice;
maxAngelTotal = series.maxAngelTotal;
baseAura = uint8(series.baseAura);
baseBattlePower = series.baseBattlePower;
lastSellTime = series.lastSellTime;
liveTime = series.liveTime;
}
function getAngel(uint64 _angelId) constant public returns(uint64 angelId, uint8 angelCardSeriesId, uint16 battlePower, uint8 aura, uint16 experience, uint price, uint64 createdTime, uint64 lastBattleTime, uint64 lastVsBattleTime, uint16 lastBattleResult, address owner) {
Angel memory angel = angelCollection[_angelId];
angelId = angel.angelId;
angelCardSeriesId = angel.angelCardSeriesId;
battlePower = angel.battlePower;
aura = uint8(angel.aura);
experience = angel.experience;
price = angel.price;
createdTime = angel.createdTime;
lastBattleTime = angel.lastBattleTime;
lastVsBattleTime = angel.lastVsBattleTime;
lastBattleResult = angel.lastBattleResult;
owner = angel.owner;
}
function getOwnerAngelCount(address _owner) constant public returns(uint) {
return ownerAngelCollection[_owner].length;
}
function getAngelLockStatus(uint64 _angelId) constant public returns (bool) {
if ((_angelId > totalAngels) || (_angelId == 0)) {revert();}
Angel storage angel = angelCollection[_angelId];
return angel.ownerLock;
}
function getAngelByIndex(address _owner, uint _index) constant public returns(uint64) {
if (_index >= ownerAngelCollection[_owner].length) {
return 0; }
return ownerAngelCollection[_owner][_index];
}
function getTotalAngelCardSeries() constant public returns (uint8) {
return totalAngelCardSeries;
}
function getTotalAngels() constant public returns (uint64) {
return totalAngels;
}
}
| 216,352 | 53 |
09206765b78a74c70bb42e5d3fa7dda226d1734525dc3ae4e773751ee1411eae
| 20,981 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TT8qV2n6rLapwPQUcs9EW1WYue3VmDqumq_MyTronBot.sol
| 5,468 | 19,696 |
//SourceUnit: mytronbot.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MyTronBot is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant ADMIN_ENTRY_RATE = 100;
uint256 private constant ADMIN_EXIT_RATE = 15;
uint256 private constant REFERENCE_RATE = 130;
uint256 public constant REFERENCE_LEVEL1_RATE = 80;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
uint256 private totalInvestmentsCount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
marketingAccount_ = msg.sender;
referenceAccount_=msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(100, 20*60*60*24,100));
investmentPlans_.push(Objects.Plan(120, 15*60*60*24,120));
investmentPlans_.push(Objects.Plan(41, 46*60*60*24,51));
investmentPlans_.push(Objects.Plan(51, 27*60*60*24,61));
investmentPlans_.push(Objects.Plan(61,18*60*60*24,71));
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getInvestmentsCount() public view returns (uint256){
return totalInvestmentsCount_;
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256,uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
totalInvestmentsCount_=totalInvestmentsCount_.add(1);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer((_amount.mul(50)).div(1000));
return true;
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0)
{
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(marketingPercentage));
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);//*
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 287,679 | 54 |
b98b71d9524794b1a5c432ed854fbe3e1ca7b128d683de8cfd8e95ca0b8fd902
| 14,872 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x2abf00b596f4cb10384654dcd76253b3140d35ff.sol
| 3,398 | 13,291 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.6;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] public m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) public m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) public m_pending;
bytes32[] public m_pendingIndex;
}
// uses is specified in the modifier.
contract daylimit is multiowned {
// MODIFIERS
// simple modifier for daily limit.
modifier limitedDaily(uint _value) {
if (underLimit(_value))
_;
}
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32);
function confirm(bytes32 _h) returns (bool);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
SingleTransact(msg.sender, _value, _to, _data);
// yes - just execute the call.
bool rc = _to.call.value(_value)(_data);
return 0;
}
// determine our operation hash.
_r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
bool rc = m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) public m_txs;
}
| 270,922 | 55 |
a0b7188ebd85438f601faa4b527e2155b9a81af58aab2579e68132e85d698077
| 34,397 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/token/ERC721/ERC721_flat.sol
| 4,069 | 16,553 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
| 63,546 | 56 |
b34b0e6c93737336b40885ede78f1ee9d77aa88dd6f84369eda0fdb110893d30
| 12,566 |
.sol
|
Solidity
| false |
443847069
|
JellyProtocol/JellyResearch
|
d453ec0c162eb5d6aa6f4ac8776b363cd52b6b36
|
contracts/KP3R/StakingRewardsV3.sol
| 3,217 | 12,282 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
library PoolAddress {
bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;
struct PoolKey {
address token0;
address token1;
uint24 fee;
}
function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
require(key.token0 < key.token1);
pool = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encode(key.token0, key.token1, key.fee)),
POOL_INIT_CODE_HASH)))));
}
}
interface erc20 {
function transfer(address recipient, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function balanceOf(address) external view returns (uint);
}
interface PositionManagerV3 {
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
function positions(uint256 tokenId)
external
view
returns (uint96 nonce,
address operator,
address token0,
address token1,
uint24 fee,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1);
function safeTransferFrom(address from, address to, uint tokenId) external;
function ownerOf(uint tokenId) external view returns (address);
function transferFrom(address from, address to, uint tokenId) external;
function collect(CollectParams calldata params) external payable returns (uint amount0, uint amount1);
}
interface UniV3 {
function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
external
view
returns (int56 tickCumulativeInside,
uint160 secondsPerLiquidityInsideX128,
uint32 secondsInside);
function slot0() external view returns (uint160, int24, uint16, uint16, uint16, uint8, bool);
}
contract StakingRewardsV3 {
address immutable public reward;
address immutable public pool;
address constant factory = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
PositionManagerV3 constant nftManager = PositionManagerV3(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
uint constant DURATION = 7 days;
uint constant PRECISION = 10 ** 18;
uint rewardRate;
uint periodFinish;
uint lastUpdateTime;
uint rewardPerLiquidityStored;
uint public forfeit;
mapping(uint => uint) public tokenRewardPerLiquidityPaid;
mapping(uint => uint) public rewards;
address public governance;
address public nextGovernance;
uint public delayGovernance;
address public treasury;
address public nextTreasury;
uint public delayTreasury;
uint32 constant DELAY = 1 days;
struct time {
uint32 timestamp;
uint32 secondsInside;
}
mapping(uint => time) public elapsed;
mapping(uint => address) public owners;
mapping(address => uint[]) public tokenIds;
mapping(uint => uint) public liquidityOf;
uint public totalLiquidity;
uint public earned0;
uint public earned1;
event RewardPaid(address indexed sender, uint tokenId, uint reward);
event RewardAdded(address indexed sender, uint reward);
event Deposit(address indexed sender, uint tokenId, uint liquidity);
event Withdraw(address indexed sender, uint tokenId, uint liquidity);
event Collect(address indexed sender, uint tokenId, uint amount0, uint amount1);
constructor(address _reward, address _pool, address _governance, address _treasury) {
reward = _reward;
pool = _pool;
governance = _governance;
treasury = _treasury;
}
modifier onlyGovernance() {
require(msg.sender == governance);
_;
}
function setGovernance(address _governance) external onlyGovernance {
nextGovernance = _governance;
delayGovernance = block.timestamp + DELAY;
}
function acceptGovernance() external {
require(msg.sender == nextGovernance && delayGovernance < block.timestamp);
governance = nextGovernance;
}
function setTreasury(address _treasury) external onlyGovernance {
nextTreasury = _treasury;
delayTreasury = block.timestamp + DELAY;
}
function commitTreasury() external onlyGovernance {
require(delayTreasury < block.timestamp);
treasury = nextTreasury;
}
function getTokenIdsLength(address _owner) external view returns (uint) {
return tokenIds[_owner].length;
}
function getTokenIds(address _owner) external view returns (uint[] memory) {
return tokenIds[_owner];
}
function lastTimeRewardApplicable() public view returns (uint) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerLiquidity() public view returns (uint) {
if (totalLiquidity == 0) {
return rewardPerLiquidityStored;
}
return rewardPerLiquidityStored + ((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * PRECISION / totalLiquidity);
}
function collect(uint tokenId) external {
_collect(tokenId);
}
function _collect(uint tokenId) internal {
if (owners[tokenId] != address(0)) {
PositionManagerV3.CollectParams memory _claim = PositionManagerV3.CollectParams(tokenId, treasury, type(uint128).max, type(uint128).max);
(uint amount0, uint amount1) = nftManager.collect(_claim);
earned0 += amount0;
earned1 += amount1;
emit Collect(msg.sender, tokenId, amount0, amount1);
}
}
function earned(uint tokenId) public view returns (uint claimable, uint32 secondsInside, uint forfeited) {
(,,,,,int24 _tickLower,int24 _tickUpper,,,,,) = nftManager.positions(tokenId);
(,,secondsInside) = UniV3(pool).snapshotCumulativesInside(_tickLower, _tickUpper);
uint _liquidity = liquidityOf[tokenId];
time memory _elapsed = elapsed[tokenId];
uint _maxSecondsElapsed = lastTimeRewardApplicable() - Math.min(_elapsed.timestamp, periodFinish);
if (_maxSecondsElapsed > 0) {
uint _secondsInside = Math.min(_maxSecondsElapsed, (secondsInside - _elapsed.secondsInside));
uint _reward = (_liquidity * (rewardPerLiquidity() - tokenRewardPerLiquidityPaid[tokenId]) / PRECISION);
uint _earned = _reward * _secondsInside / _maxSecondsElapsed;
forfeited = _reward - _earned;
claimable = _earned;
}
claimable += rewards[tokenId];
}
function getRewardForDuration() external view returns (uint) {
return rewardRate * DURATION;
}
function deposit(uint tokenId) external update(tokenId) {
(,,address token0,address token1,uint24 fee,int24 tickLower,int24 tickUpper,uint128 _liquidity,,,,) = nftManager.positions(tokenId);
address _pool = PoolAddress.computeAddress(factory,PoolAddress.PoolKey({token0: token0, token1: token1, fee: fee}));
require(pool == _pool);
require(_liquidity > 0);
(,int24 _tick,,,,,) = UniV3(_pool).slot0();
require(tickLower < _tick && _tick < tickUpper);
nftManager.transferFrom(msg.sender, address(this), tokenId);
owners[tokenId] = msg.sender;
tokenIds[msg.sender].push(tokenId);
liquidityOf[tokenId] = _liquidity;
totalLiquidity += _liquidity;
emit Deposit(msg.sender, tokenId, _liquidity);
}
function _findIndex(uint[] memory array, uint element) internal pure returns (uint i) {
for (i = 0; i < array.length; i++) {
if (array[i] == element) {
break;
}
}
}
function _remove(uint[] storage array, uint element) internal {
uint _index = _findIndex(array, element);
uint _length = array.length;
if (_index >= _length) return;
if (_index < _length-1) {
array[_index] = array[_length-1];
}
array.pop();
}
function withdraw(uint tokenId) public update(tokenId) {
_collect(tokenId);
_withdraw(tokenId);
}
function _withdraw(uint tokenId) internal {
require(owners[tokenId] == msg.sender);
uint _liquidity = liquidityOf[tokenId];
liquidityOf[tokenId] = 0;
totalLiquidity -= _liquidity;
owners[tokenId] = address(0);
_remove(tokenIds[msg.sender], tokenId);
nftManager.transferFrom(address(this), msg.sender, tokenId);
emit Withdraw(msg.sender, tokenId, _liquidity);
}
function getRewards() external {
uint[] memory _tokens = tokenIds[msg.sender];
for (uint i = 0; i < _tokens.length; i++) {
getReward(_tokens[i]);
}
}
function getReward(uint tokenId) public update(tokenId) {
_collect(tokenId);
uint _reward = rewards[tokenId];
if (_reward > 0) {
rewards[tokenId] = 0;
_safeTransfer(reward, _getRecipient(tokenId), _reward);
emit RewardPaid(msg.sender, tokenId, _reward);
}
}
function _getRecipient(uint tokenId) internal view returns (address) {
if (owners[tokenId] != address(0)) {
return owners[tokenId];
} else {
return nftManager.ownerOf(tokenId);
}
}
function withdraw() external {
uint[] memory _tokens = tokenIds[msg.sender];
for (uint i = 0; i < _tokens.length; i++) {
withdraw(_tokens[i]);
}
}
function deposit_reward_token(address token, uint _reward) external {
require(token == reward);
notify(_reward);
}
function notify(uint amount) public onlyGovernance update(0) {
if (block.timestamp >= periodFinish) {
rewardRate = amount / DURATION;
} else {
uint _remaining = periodFinish - block.timestamp;
uint _leftover = _remaining * rewardRate;
rewardRate = (amount + _leftover) / DURATION;
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp + DURATION;
_safeTransferFrom(reward, msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function refund() external onlyGovernance {
uint _forfeit = forfeit;
forfeit = 0;
_safeTransfer(reward, treasury, _forfeit);
}
modifier update(uint tokenId) {
uint _rewardPerLiquidityStored = rewardPerLiquidity();
uint _lastUpdateTime = lastTimeRewardApplicable();
rewardPerLiquidityStored = _rewardPerLiquidityStored;
lastUpdateTime = _lastUpdateTime;
if (tokenId != 0) {
(uint _reward, uint32 _secondsInside, uint _forfeited) = earned(tokenId);
tokenRewardPerLiquidityPaid[tokenId] = _rewardPerLiquidityStored;
rewards[tokenId] = _reward;
forfeit += _forfeited;
if (elapsed[tokenId].timestamp < _lastUpdateTime) {
elapsed[tokenId] = time(uint32(_lastUpdateTime), _secondsInside);
}
}
_;
}
function _safeTransfer(address token, address to, uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 21,041 | 57 |
8a40a4a78024d4feaff43b1d72f7ce079820babd6739afcdbaab152858db17ff
| 14,964 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xfa55951f84bfbe2e6f95aa74b58cc7047f9f0644.sol
| 3,434 | 13,706 |
pragma solidity ^0.4.21;
contract Owned {
/// 'owner' is the only address that can call a function with
/// this modifier
address public owner;
address internal newOwner;
///@notice The constructor assigns the message sender to be 'owner'
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event updateOwner(address _oldOwner, address _newOwner);
///change the owner
function changeOwner(address _newOwner) public onlyOwner returns(bool) {
require(owner != _newOwner);
newOwner = _newOwner;
return true;
}
/// accept the ownership
function acceptNewOwner() public returns(bool) {
require(msg.sender == newOwner);
emit updateOwner(owner, newOwner);
owner = newOwner;
return true;
}
}
// Safe maths, borrowed from OpenZeppelin
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || 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;
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;
}
}
contract ERC20Token {
/// total amount of tokens
uint256 public totalSupply;
/// user tokens
mapping (address => uint256) public balances;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Controlled is Owned, ERC20Token {
using SafeMath for uint;
uint256 public releaseStartTime;
uint256 oneMonth = 3600 * 24 * 30;
// Flag that determines if the token is transferable or not
bool public emergencyStop = false;
struct userToken {
uint256 UST;
uint256 addrLockType;
}
mapping (address => userToken) public userReleaseToken;
modifier canTransfer {
require(emergencyStop == false);
_;
}
modifier releaseTokenValid(address _user, uint256 _time, uint256 _value) {
uint256 _lockTypeIndex = userReleaseToken[_user].addrLockType;
if(_lockTypeIndex != 0) {
require (balances[_user].sub(_value) >= userReleaseToken[_user].UST.sub(calcReleaseToken(_user, _time, _lockTypeIndex)));
}
_;
}
function canTransferUST(bool _bool) public onlyOwner{
emergencyStop = _bool;
}
/// @notice get `_user` transferable token amount
/// @param _user The user's address
/// @param _time The present time
/// @param _lockTypeIndex The user's investment lock type
/// @return Return the amount of user's transferable token
function calcReleaseToken(address _user, uint256 _time, uint256 _lockTypeIndex) internal view returns (uint256) {
uint256 _timeDifference = _time.sub(releaseStartTime);
uint256 _whichPeriod = getPeriod(_lockTypeIndex, _timeDifference);
if(_lockTypeIndex == 1) {
return (percent(userReleaseToken[_user].UST, 25) + percent(userReleaseToken[_user].UST, _whichPeriod.mul(25)));
}
if(_lockTypeIndex == 2) {
return (percent(userReleaseToken[_user].UST, 25) + percent(userReleaseToken[_user].UST, _whichPeriod.mul(25)));
}
if(_lockTypeIndex == 3) {
return (percent(userReleaseToken[_user].UST, 10) + percent(userReleaseToken[_user].UST, _whichPeriod.mul(15)));
}
revert();
}
/// @notice get time period for the given '_lockTypeIndex'
/// @param _lockTypeIndex The user's investment locktype index
/// @param _timeDifference The passed time since releaseStartTime to now
/// @return Return the time period
function getPeriod(uint256 _lockTypeIndex, uint256 _timeDifference) internal view returns (uint256) {
if(_lockTypeIndex == 1) { //The lock for the usechain coreTeamSupply
uint256 _period1 = (_timeDifference.div(oneMonth)).div(12);
if(_period1 >= 3){
_period1 = 3;
}
return _period1;
}
if(_lockTypeIndex == 2) { //The lock for medium investment
uint256 _period2 = _timeDifference.div(oneMonth);
if(_period2 >= 3){
_period2 = 3;
}
return _period2;
}
if(_lockTypeIndex == 3) { //The lock for massive investment
uint256 _period3 = _timeDifference.div(oneMonth);
if(_period3 >= 6){
_period3 = 6;
}
return _period3;
}
revert();
}
function percent(uint _token, uint _percentage) internal pure returns (uint) {
return _percentage.mul(_token).div(100);
}
}
contract standardToken is ERC20Token, Controlled {
mapping (address => mapping (address => uint256)) public allowances;
/// @param _owner The address that's balance is being requested
/// @return The balance of `_owner` at the current block
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
/// @notice Send `_value` tokens to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to,
uint256 _value)
public
canTransfer
releaseTokenValid(msg.sender, now, _value)
returns (bool)
{
require (balances[msg.sender] >= _value); // Throw if sender has insufficient balance
require (balances[_to] + _value >= balances[_to]); // Throw if owerflow detected
balances[msg.sender] -= _value; // Deduct senders balance
balances[_to] += _value; // Add recivers balance
emit Transfer(msg.sender, _to, _value); // Raise Transfer event
return true;
}
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return True if the approval was successful
function approve(address _spender, uint256 _value) public returns (bool success) {
allowances[msg.sender][_spender] = _value; // Set allowance
emit Approval(msg.sender, _spender, _value); // Raise Approval event
return true;
}
/// @notice `msg.sender` approves `_spender` to send `_value` 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 _value The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
approve(_spender, _value); // Set approval to contract for _value
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) {
revert();
}
return true;
}
/// @notice Send `_value` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _value The amount of tokens to be transferred
/// @return True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _value) public canTransfer releaseTokenValid(msg.sender, now, _value) returns (bool success) {
require (balances[_from] >= _value); // Throw if sender does not have enough balance
require (balances[_to] + _value >= balances[_to]); // Throw if overflow detected
require (_value <= allowances[_from][msg.sender]); // Throw if you do not have allowance
balances[_from] -= _value; // Deduct senders balance
balances[_to] += _value; // Add recipient balance
allowances[_from][msg.sender] -= _value; // Deduct allowance for this address
emit Transfer(_from, _to, _value); // Raise Transfer event
return true;
}
/// @dev This function makes it easy to read the `allowances[]` map
/// @param _owner The address of the account that owns the token
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens of _owner that _spender is allowed to spend
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowances[_owner][_spender];
}
}
contract UST is Owned, standardToken {
string constant public name = "UseChainToken";
string constant public symbol = "UST";
uint constant public decimals = 18;
uint256 public totalSupply = 0;
uint256 constant public topTotalSupply = 2 * 10**10 * 10**decimals;
uint public forSaleSupply = percent(topTotalSupply, 45);
uint public marketingPartnerSupply = percent(topTotalSupply, 5);
uint public coreTeamSupply = percent(topTotalSupply, 15);
uint public technicalCommunitySupply = percent(topTotalSupply, 15);
uint public communitySupply = percent(topTotalSupply, 20);
uint public softCap = percent(topTotalSupply, 30);
function () public {
revert();
}
/// @dev Owner can change the releaseStartTime when needs
/// @param _time The releaseStartTime, UTC timezone
function setRealseTime(uint256 _time) public onlyOwner {
releaseStartTime = _time;
}
/// @dev This owner allocate token for private sale
/// @param _owners The address of the account that owns the token
/// @param _values The amount of tokens
/// @param _addrLockType The locktype for different investment type
function allocateToken(address[] _owners, uint256[] _values, uint256[] _addrLockType) public onlyOwner {
require ((_owners.length == _values.length) && (_values.length == _addrLockType.length));
for(uint i = 0; i < _owners.length ; i++){
uint256 value = _values[i] * 10 ** decimals;
totalSupply = totalSupply.add(value);
balances[_owners[i]] = balances[_owners[i]].add(value); // Set minted coins to target
emit Transfer(0x0, _owners[i], value);
userReleaseToken[_owners[i]].UST = userReleaseToken[_owners[i]].UST.add(value);
userReleaseToken[_owners[i]].addrLockType = _addrLockType[i];
}
}
/// @dev This owner allocate token for candy airdrop
/// @param _owners The address of the account that owns the token
/// @param _values The amount of tokens
function allocateCandyToken(address[] _owners, uint256[] _values) public onlyOwner {
for(uint i = 0; i < _owners.length ; i++){
uint256 value = _values[i] * 10 ** decimals;
totalSupply = totalSupply.add(value);
balances[_owners[i]] = balances[_owners[i]].add(value);
emit Transfer(0x0, _owners[i], value);
}
}
}
| 19,842 | 58 |
287c4cbb0dc525c99f92935cc042a3c93bb0a3cb72dd9d2cf76e4b847301c16c
| 13,750 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xeb0058ce60d753004b0efa2164f88b2a5b528e7d.sol
| 3,343 | 12,996 |
pragma solidity ^0.4.16;
// copyright contact@Etheremon.com
contract SafeMath {
function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
contract EtheremonDataBase is EtheremonEnum, BasicAccessControl, SafeMath {
uint64 public totalMonster;
uint32 public totalClass;
// write
function withdrawEther(address _sendTo, uint _amount) onlyOwner public returns(ResultCode);
function addElementToArrayType(ArrayType _type, uint64 _id, uint8 _value) onlyModerators public returns(uint);
function updateIndexOfArrayType(ArrayType _type, uint64 _id, uint _index, uint8 _value) onlyModerators public returns(uint);
function setMonsterClass(uint32 _classId, uint256 _price, uint256 _returnPrice, bool _catchable) onlyModerators public returns(uint32);
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64);
function setMonsterObj(uint64 _objId, string _name, uint32 _exp, uint32 _createIndex, uint32 _lastClaimIndex) onlyModerators public;
function increaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function decreaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function removeMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function addMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function clearMonsterReturnBalance(uint64 _monsterId) onlyModerators public returns(uint256 amount);
function collectAllReturnBalance(address _trainer) onlyModerators public returns(uint256 amount);
function transferMonster(address _from, address _to, uint64 _monsterId) onlyModerators public returns(ResultCode);
function addExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function deductExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function setExtraBalance(address _trainer, uint256 _amount) onlyModerators public;
// read
function getSizeArrayType(ArrayType _type, uint64 _id) constant public returns(uint);
function getElementInArrayType(ArrayType _type, uint64 _id, uint _index) constant public returns(uint8);
function getMonsterClass(uint32 _classId) constant public returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant public returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getMonsterName(uint64 _objId) constant public returns(string name);
function getExtraBalance(address _trainer) constant public returns(uint256);
function getMonsterDexSize(address _trainer) constant public returns(uint);
function getMonsterObjId(address _trainer, uint index) constant public returns(uint64);
function getExpectedBalance(address _trainer) constant public returns(uint256);
function getMonsterReturn(uint64 _objId) constant public returns(uint256 current, uint256 total);
}
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);
}
contract BattleInterface {
function createCastleWithToken(address _trainer, uint32 _noBrick, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3) external;
}
contract TransformInterface {
function removeHatchingTimeWithToken(address _trainer) external;
function buyEggWithToken(address _trainer) external;
}
contract AdventureInterface {
function placeEMONTBid(address _bidder, uint8 _siteId, uint _bidAmount) external;
}
contract EtheremonPayment is EtheremonEnum, BasicAccessControl, SafeMath {
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
uint8 constant public GEN0_NO = 24;
enum PayServiceType {
NONE,
FAST_HATCHING,
RANDOM_EGG,
ADVENTURE_PRESALE
}
struct MonsterClassAcc {
uint32 classId;
uint256 price;
uint256 returnPrice;
uint32 total;
bool catchable;
}
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
// linked smart contract
address public dataContract;
address public battleContract;
address public tokenContract;
address public transformContract;
address public adventureContract;
address private lastHunter = address(0x0);
// config
uint public brickPrice = 6 * 10 ** 8; // 6 tokens
uint public fastHatchingPrice = 35 * 10 ** 8; // 15 tokens
uint public buyEggPrice = 80 * 10 ** 8; // 80 tokens
uint public tokenPrice = 0.004 ether / 10 ** 8;
uint public maxDexSize = 200;
// event
event EventCatchMonster(address indexed trainer, uint64 objId);
// modifier
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireBattleContract {
require(battleContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireTransformContract {
require(transformContract != address(0));
_;
}
function EtheremonPayment(address _dataContract, address _battleContract, address _tokenContract, address _transformContract, address _adventureContract) public {
dataContract = _dataContract;
battleContract = _battleContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
adventureContract = _adventureContract;
}
// helper
function getRandom(uint8 maxRan, uint8 index, address priAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(priAddress);
for (uint8 i = 0; i < index && i < 6; i ++) {
genNum /= 256;
}
return uint8(genNum % maxRan);
}
// admin
function withdrawToken(address _sendTo, uint _amount) onlyModerators requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function setContract(address _dataContract, address _battleContract, address _tokenContract, address _transformContract, address _adventureContract) onlyModerators external {
dataContract = _dataContract;
battleContract = _battleContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
adventureContract = _adventureContract;
}
function setConfig(uint _brickPrice, uint _tokenPrice, uint _maxDexSize, uint _fastHatchingPrice, uint _buyEggPrice) onlyModerators external {
brickPrice = _brickPrice;
tokenPrice = _tokenPrice;
maxDexSize = _maxDexSize;
fastHatchingPrice = _fastHatchingPrice;
buyEggPrice = _buyEggPrice;
}
// battle
function giveBattleBonus(address _trainer, uint _amount) isActive requireBattleContract requireTokenContract public {
if (msg.sender != battleContract)
revert();
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(_trainer, _amount);
}
function createCastle(address _trainer, uint _tokens, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3) isActive requireBattleContract requireTokenContract public returns(uint){
if (msg.sender != tokenContract)
revert();
BattleInterface battle = BattleInterface(battleContract);
battle.createCastleWithToken(_trainer, uint32(_tokens/brickPrice), _name, _a1, _a2, _a3, _s1, _s2, _s3);
return _tokens;
}
function catchMonster(address _trainer, uint _tokens, uint32 _classId, string _name) isActive requireDataContract requireTokenContract public returns(uint){
if (msg.sender != tokenContract)
revert();
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterClassAcc memory class;
(class.classId, class.price, class.returnPrice, class.total, class.catchable) = data.getMonsterClass(_classId);
if (class.classId == 0 || class.catchable == false) {
revert();
}
// can not keep too much etheremon
if (data.getMonsterDexSize(_trainer) > maxDexSize)
revert();
uint requiredToken = class.price/tokenPrice;
if (_tokens < requiredToken)
revert();
// add monster
uint64 objId = data.addMonsterObj(_classId, _trainer, _name);
// generate base stat for the previous one
for (uint i=0; i < STAT_COUNT; i+= 1) {
uint8 value = getRandom(STAT_MAX, uint8(i), lastHunter) + data.getElementInArrayType(ArrayType.STAT_START, uint64(_classId), i);
data.addElementToArrayType(ArrayType.STAT_BASE, objId, value);
}
lastHunter = _trainer;
EventCatchMonster(_trainer, objId);
return requiredToken;
}
function payService(address _trainer, uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3, uint64 _param4, uint64 _param5, uint64 _param6) isActive requireTransformContract public returns(uint result) {
if (msg.sender != tokenContract)
revert();
TransformInterface transform = TransformInterface(transformContract);
AdventureInterface adventure = AdventureInterface(adventureContract);
if (_type == uint32(PayServiceType.FAST_HATCHING)) {
// remove hatching time
if (_tokens < fastHatchingPrice)
revert();
transform.removeHatchingTimeWithToken(_trainer);
return fastHatchingPrice;
} else if (_type == uint32(PayServiceType.RANDOM_EGG)) {
if (_tokens < buyEggPrice)
revert();
transform.buyEggWithToken(_trainer);
return buyEggPrice;
} else if (_type == uint32(PayServiceType.ADVENTURE_PRESALE)) {
adventure.placeEMONTBid(_trainer, uint8(_param1), _tokens);
return _tokens;
} else {
revert();
}
}
}
| 147,481 | 59 |
0b8c0e61f31f27237a3b50db736e01ff92d501302fd65c51c1f2a8f76b767edc
| 24,092 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEmfmn5YFaFVb7kq8s8VCC1AmQHyKsxPN7_TRXRacing.sol
| 6,302 | 23,242 |
//SourceUnit: TRXRacing.sol
pragma solidity 0.5.10;
contract TRXRacing {
using SafeMath for uint;
uint constant internal DEPOSITS_MAX = 200;
uint constant internal INVEST_MIN_AMOUNT = 500 trx;
uint constant internal WITHDRAW_MIN_AMOUNT = 200 trx;
uint constant internal BASE_PERCENT = 500;
uint constant internal BOOST_PERCENT = 200;
uint[] internal REFERRAL_PERCENTS = [400, 200, 100];
uint constant internal RACEBONUS = 1;
uint constant internal RACETICKET = 250 trx;
uint constant internal FUND_FEE = 400;
uint constant internal MARKETING_FEE = 800;
uint constant internal PROJECT_FEE = 200;
uint[] internal RACE_WIN_PERCENT = [28, 20, 16, 16];
uint internal RACE_TICKET_LIMIT = 7;
uint constant internal MAX_DEPOSIT_PERCENT = 50;
uint constant internal PERCENTS_DIVIDER = 10000;
uint constant internal USER_DEPOSITS_STEP = 1000 trx;
uint constant internal TIME_STEP = 1 days;
uint internal totalDeposits;
uint internal totalInvested;
uint internal totalWithdrawn;
uint raceCurrentPot;
uint raceCycles;
uint raceCurrentTicketsCount;
uint raceLastTicket;
uint raceTotalTicketsCount;
address raceLastWin1a;
address raceLastWin2a;
address raceLastWin3a;
address raceLastWin4a;
address payable internal marketingAddress;
address payable internal projectAddress;
address payable internal fundAddress;
struct cRace {
address runnerId;
uint32 ticketNumber;
}
struct nRace {
cRace[] currentRace;
}
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint32 start;
}
struct User {
Deposit[] deposits;
address referrer;
uint24[3] refs;
uint32 checkpoint;
uint32 firstinvest;
uint32 booST;
uint32 booET;
uint32 dboost;
uint32 aboost;
uint32 rparticipations;
uint32 withdraws;
uint64 bonus;
uint64 rbonus;
uint64 wrprofit;
}
mapping (address => User) internal users;
mapping (uint => nRace) internal nraces;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event FeePayed(address indexed user, uint totalAmount);
event NewParticipantRace(address indexed user, uint amount, uint pt);
event WithdrawPrize(address indexed, uint amount);
constructor(address payable marketingAddr, address payable fundAddr , address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(fundAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
fundAddress = fundAddr;
projectAddress = projectAddr;
}
function PayoutFees(uint amount) internal {
uint msgValue = amount;
uint fundFee = msgValue.mul(FUND_FEE).div(PERCENTS_DIVIDER);
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
fundAddress.transfer(fundFee);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
emit FeePayed(msg.sender, marketingFee.add(fundFee.add(projectFee)));
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 100 TRX");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 200 deposits from address");
PayoutFees(msg.value);
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 (uint i = 0; i < 3; i++) {
if (upline != address(0)) {
uint amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
user.firstinvest = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msg.value), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msg.value);
totalDeposits++;
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
uint cB = address(this).balance;
User storage user = users[msg.sender];
require (block.timestamp >= uint(user.checkpoint).add(TIME_STEP.mul(3).div(2)) && cB > 0, "Try Again in 36hours");
uint userPercentRate = getUserPercentRate(msg.sender);
uint totalAmount;
uint dividends;
uint divsboost;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3).div(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (user.dboost > 0) {
if (user.deposits[i].start > user.booET) {
divsboost = 0;
} else {
divsboost = (uint(user.deposits[i].amount).mul(BOOST_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.booST)))
.div(TIME_STEP);
}
if (divsboost > uint(user.deposits[i].amount).mul(10).div(100)) {
divsboost = (uint(user.deposits[i].amount).mul(10).div(100));
}
}
if (uint(user.deposits[i].withdrawn).add(dividends).add(divsboost) > uint(user.deposits[i].amount).mul(3).div(2)) {
dividends = (uint(user.deposits[i].amount).mul(3).div(2)).sub(uint(user.deposits[i].withdrawn).add(divsboost));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends).add(divsboost)); /// changing of storage data
totalAmount = totalAmount.add(dividends).add(divsboost);
}
}
uint referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > WITHDRAW_MIN_AMOUNT, "User has no minimun");
if (cB < totalAmount) {
totalAmount = cB;
}
user.dboost = 0;
user.booET = uint32(block.timestamp);
user.checkpoint = uint32(block.timestamp);
user.withdraws++;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function raceDeposit() external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
User storage user = users[msg.sender];
require(user.deposits.length > 0 && msg.value == RACETICKET,"Deposit is require first");
nRace storage nrace = nraces[raceCycles];
raceTotalTicketsCount ++;
raceCurrentTicketsCount ++;
user.rparticipations ++;
raceCurrentPot = raceCurrentPot.add(msg.value);
nrace.currentRace.push(cRace(msg.sender, uint32(raceLastTicket.add(1))));
raceLastTicket++;
emit NewParticipantRace(msg.sender, msg.value, raceLastTicket);
if (raceCurrentTicketsCount == RACE_TICKET_LIMIT) {
payRaceWin();
raceCurrentPot = 0;
raceCurrentTicketsCount = 0;
raceLastTicket = 0;
raceCycles++;
}
}
function getRaceWin(uint fr, uint to, uint mod) view internal returns (uint) {
uint A = minZero(to, fr).add(1);
uint B = fr;
uint value = uint(uint(keccak256(abi.encode(block.timestamp.mul(mod), block.difficulty.mul(mod))))%A).add(B);
return value;
}
function payRaceWin() internal {
nRace storage nrace = nraces[raceCycles];
uint win1 = getRaceWin(1, RACE_TICKET_LIMIT, 1);
uint win2 = getRaceWin(1, RACE_TICKET_LIMIT, 2);
uint win3 = getRaceWin(1, RACE_TICKET_LIMIT, 3);
uint win4 = getRaceWin(1, RACE_TICKET_LIMIT, 4);
uint profit;
uint fundFee = raceCurrentPot.mul(400).div(PERCENTS_DIVIDER);
uint marketingFee = raceCurrentPot.mul(400).div(PERCENTS_DIVIDER);
uint projectFee = raceCurrentPot.mul(200).div(PERCENTS_DIVIDER);
fundAddress.transfer(fundFee);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
emit FeePayed(msg.sender, marketingFee.add(fundFee.add(projectFee)));
for(uint i = 0; i < 7; i++) {
if (nrace.currentRace[i].ticketNumber == win1) {
profit = (raceCurrentPot.mul(RACE_WIN_PERCENT[0])).div(100);
users[nrace.currentRace[i].runnerId].rbonus = uint64(uint(users[nrace.currentRace[i].runnerId].rbonus).add(profit));
raceLastWin1a = nrace.currentRace[i].runnerId;
}
if (nrace.currentRace[i].ticketNumber == win2) {
profit = (raceCurrentPot.mul(RACE_WIN_PERCENT[1])).div(100);
users[nrace.currentRace[i].runnerId].rbonus = uint64(uint(users[nrace.currentRace[i].runnerId].rbonus).add(profit));
raceLastWin2a = nrace.currentRace[i].runnerId;
}
if (nrace.currentRace[i].ticketNumber == win3) {
profit = (raceCurrentPot.mul(RACE_WIN_PERCENT[2])).div(100);
users[nrace.currentRace[i].runnerId].rbonus = uint64(uint(users[nrace.currentRace[i].runnerId].rbonus).add(profit));
raceLastWin3a = nrace.currentRace[i].runnerId;
}
if (nrace.currentRace[i].ticketNumber == win4) {
profit = (raceCurrentPot.mul(RACE_WIN_PERCENT[3])).div(100);
users[nrace.currentRace[i].runnerId].rbonus = uint64(uint(users[nrace.currentRace[i].runnerId].rbonus).add(profit));
raceLastWin4a = nrace.currentRace[i].runnerId;
}
}
}
function Booster() public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
User storage user = users[msg.sender];
require (block.timestamp >= uint(user.firstinvest).add(TIME_STEP.mul(2)) && block.timestamp >= user.booET, "Boost active");
uint damount = getUserTotalDeposits(msg.sender);
require (msg.value == damount.div(10), "Deposit 10%");
user.deposits.push(Deposit(uint64(msg.value), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msg.value);
if (user.dboost == 0){
user.booST = uint32(block.timestamp);
user.booET = uint32(uint(block.timestamp).add(TIME_STEP.mul(5)));
user.dboost++;
}else{
user.booST = uint32(uint(block.timestamp).sub((TIME_STEP.mul(5)).mul(user.dboost)));
user.booET = uint32(uint(block.timestamp).add(TIME_STEP.mul(5)));
user.dboost++;
}
user.aboost++;
}
function withdrawRBonus() public {
uint totalAmount;
User storage user = users[msg.sender];
uint RacingBonus = user.rbonus;
require (RacingBonus > 0,"No Racing Profit");
totalAmount = totalAmount.add(RacingBonus);
user.wrprofit = uint64(uint(user.wrprofit).add(RacingBonus));
user.rbonus = 0;
uint cB = address(this).balance;
if (cB < totalAmount) {
totalAmount = cB;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getBoostdivs(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint totalDividends;
uint divsboost;
for (uint i = 0; i < user.deposits.length; i++) {
if (user.dboost > 0) {
if (user.deposits[i].start > user.booET) {
divsboost = 0;
} else {
divsboost = (uint(user.deposits[i].amount).mul(BOOST_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.booST)))
.div(TIME_STEP);
}
if (divsboost > uint(user.deposits[i].amount).mul(10).div(100)) {
divsboost = (uint(user.deposits[i].amount).mul(10).div(100));
}
totalDividends = totalDividends.add(divsboost);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getBoost(address userAddress) internal view returns (uint){
User storage user = users[userAddress];
uint Pboost;
if (user.booET > block.timestamp){
Pboost = BOOST_PERCENT;
}
else {
Pboost = 0;
}
return Pboost;
}
function getUserBasicRate(address userAddress) internal view returns (uint) {
User storage user = users[userAddress];
uint BASE_PERCENTNew;
uint userWithdraws = user.withdraws;
uint BASE_PERCENTSub = userWithdraws.mul(100);
if (BASE_PERCENTSub > BASE_PERCENT) {
BASE_PERCENTNew = 0;
}
else{
BASE_PERCENTNew = BASE_PERCENT.sub(BASE_PERCENTSub);
}
return BASE_PERCENTNew;
}
function getUserRaceRate(address userAddress) internal view returns (uint) {
User storage user = users[userAddress];
uint rparticipations= user.rparticipations;
uint LMultiplier = RACEBONUS.mul(rparticipations);
return LMultiplier;
}
function getUserDepositRate(address userAddress) internal view returns (uint) {
uint userDepositRate;
if (getUserAmountOfDeposits(userAddress) > 0) {
userDepositRate = getUserTotalDeposits(userAddress).div(USER_DEPOSITS_STEP).mul(10);
if (userDepositRate > MAX_DEPOSIT_PERCENT) {
userDepositRate = MAX_DEPOSIT_PERCENT;
}
}
return userDepositRate;
}
function getUserPercentRate(address userAddress) internal view returns (uint) {
uint userBasicRate = getUserBasicRate(userAddress);
if (isActive(userAddress)) {
uint userDepositRate = getUserDepositRate(userAddress);
uint userRaceRate = getUserRaceRate(userAddress);
return userBasicRate.add(userDepositRate).add(userRaceRate);
} else {
return userBasicRate;
}
}
function getUserAvailable(address userAddress) internal view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint totalDividends;
uint dividends;
uint divsboost;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3).div(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (user.dboost > 0) {
if (user.deposits[i].start > user.booET) {
divsboost = 0;
} else {
divsboost = (uint(user.deposits[i].amount).mul(BOOST_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.booST)))
.div(TIME_STEP);
}
if (divsboost > uint(user.deposits[i].amount).mul(10).div(100)) {
divsboost = (uint(user.deposits[i].amount).mul(10).div(100));
}
}
if (uint(user.deposits[i].withdrawn).add(dividends).add(divsboost) > uint(user.deposits[i].amount).mul(3).div(2)) {
dividends = (uint(user.deposits[i].amount).mul(3).div(2)).sub(uint(user.deposits[i].withdrawn).add(divsboost));
}
totalDividends = totalDividends.add(dividends).add(divsboost);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserAmountOfDeposits(address userAddress) internal view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) internal view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) internal view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance ,totalWithdrawn);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userBoost = getBoost(userAddress);
uint userPerc = getUserPercentRate(userAddress).add(userBoost);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserPerc (address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userBasicRate = getUserBasicRate(userAddress);
uint userDepositRate = getUserDepositRate(userAddress);
uint userRaceRate = getUserRaceRate(userAddress);
uint userBoostRate = getBoost(userAddress);
return (userPerc, userBasicRate, userDepositRate, userRaceRate, userBoostRate);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint32, uint32, uint64, uint64, uint32, uint32, uint32, uint32, uint32, uint24[3] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.firstinvest, user.withdraws, user.rbonus , user.wrprofit, user.rparticipations, user.aboost, user.dboost, user.booST,user.booET, user.refs);
}
function getUserReferralBonus(address userAddress) internal view returns(uint) {
return users[userAddress].bonus;
}
function getRunnerStats() public view returns (address, address, address, address, uint, uint, uint, uint, uint, uint) {
return (raceLastWin1a, raceLastWin2a, raceLastWin3a , raceLastWin4a ,raceCycles, raceCurrentTicketsCount, raceTotalTicketsCount, RACE_TICKET_LIMIT, RACETICKET, raceCurrentPot);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(3).div(2);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function minZero(uint a, uint b) internal pure returns(uint) {
if (a > b) {
return a - b;
} else {
return 0;
}
}
function maxVal(uint a, uint b) internal pure returns(uint) {
if (a > b) {
return a;
} else {
return b;
}
}
function minVal(uint a, uint b) internal pure returns(uint) {
if (a > b) {
return b;
} else {
return a;
}
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a, "SafeMath: subtraction overflow");
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0, "SafeMath: division by zero");
uint c = a / b;
return c;
}
}
| 292,623 | 60 |
5a6117e504abfb2a0844ccc0bb1fde4f4fd2f04d236277d9dd10aae161e1d15b
| 19,284 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/fe/Fe1AcEC8bAA289Cd8A80FEAE284d9ab6Fe216DF3_SolisiumToken.sol
| 3,199 | 12,241 |
pragma solidity ^0.4.25;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, 'only owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'not whitelisted');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface BEP20Basic {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is BEP20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract BEP20 is BEP20Basic {
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 BEP20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Whitelist {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyWhitelisted canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyWhitelisted canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract SolisiumToken is MintableToken {
struct Stats {
uint256 txs;
uint256 minted;
}
string public constant name = "Solisium Token";
string public constant symbol = "SOLS";
uint8 public constant decimals = 18;
uint256 public constant MAX_INT = 2**256 - 1;
uint256 public constant targetSupply = MAX_INT;
uint256 public totalTxs;
uint256 public players;
uint256 private mintedSupply_;
mapping(address => Stats) private stats;
address public vaultAddress;
uint8 constant internal taxDefault = 10; // 10% tax on transfers
mapping (address => uint8) private _customTaxRate;
mapping (address => bool) private _hasCustomTax;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
event TaxPayed(address from, address vault, uint256 amount);
constructor(uint256 _initialMint) Ownable() public {
addAddressToWhitelist(owner);
mint(owner, _initialMint * 1e18);
removeAddressFromWhitelist(owner);
}
function setVaultAddress(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
}
function mint(address _to, uint256 _amount) public returns (bool) {
//Never fail, just don't mint if over
if (_amount == 0 || mintedSupply_.add(_amount) > targetSupply) {
return false;
}
//Mint
super.mint(_to, _amount);
mintedSupply_ = mintedSupply_.add(_amount);
if (mintedSupply_ == targetSupply) {
mintingFinished = true;
emit MintFinished();
}
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_to].minted += _amount;
totalTxs += 1;
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
return false;
}
function calculateTransactionTax(uint256 _value, uint8 _tax) internal returns (uint256 adjustedValue, uint256 taxAmount){
taxAmount = _value.mul(_tax).div(100);
adjustedValue = _value.mul(SafeMath.sub(100, _tax)).div(100);
return (adjustedValue, taxAmount);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(_from, _value);
if (taxAmount > 0){
require(super.transferFrom(_from, vaultAddress, taxAmount));
emit TaxPayed(_from, vaultAddress, taxAmount);
}
require(super.transferFrom(_from, _to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_from].txs += 1;
totalTxs += 1;
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(msg.sender, _value);
if (taxAmount > 0){
require(super.transfer(vaultAddress, taxAmount));
emit TaxPayed(msg.sender, vaultAddress, taxAmount);
}
require(super.transfer(_to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[msg.sender].txs += 1;
totalTxs += 1;
return true;
}
function calculateTransferTaxes(address _from, uint256 _value) public view returns (uint256 adjustedValue, uint256 taxAmount){
adjustedValue = _value;
taxAmount = 0;
if (!_isExcluded[_from]) {
uint8 taxPercent = taxDefault; // set to default tax 10%
// set custom tax rate if applicable
if (_hasCustomTax[_from]){
taxPercent = _customTaxRate[_from];
}
(adjustedValue, taxAmount) = calculateTransactionTax(_value, taxPercent);
}
return (adjustedValue, taxAmount);
}
function remainingMintableSupply() public view returns (uint256) {
return targetSupply.sub(mintedSupply_);
}
function cap() public view returns (uint256) {
return targetSupply;
}
function mintedSupply() public view returns (uint256) {
return mintedSupply_;
}
function statsOf(address player) public view returns (uint256, uint256, uint256){
return (balanceOf(player), stats[player].txs, stats[player].minted);
}
//
function mintedBy(address player) public view returns (uint256){
return stats[player].minted;
}
function setAccountCustomTax(address account, uint8 taxRate) external onlyOwner() {
require(taxRate >= 0 && taxRate <= 100, "Invalid tax amount");
_hasCustomTax[account] = true;
_customTaxRate[account] = taxRate;
}
function removeAccountCustomTax(address account) external onlyOwner() {
_hasCustomTax[account] = false;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
_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];
_isExcluded[account] = false;
delete _excluded[_excluded.length - 1];
break;
}
}
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
}
| 112,531 | 61 |
41793341c1bfbd76673c96652557ae658ca70eab43c450f7b99621fd06267dab
| 14,363 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xe07159a785f4254bf3c7f1454eabba5051d4276e.sol
| 3,821 | 13,237 |
pragma solidity ^0.5.8;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
address public ceoAddress = address(0xFce92D4163AA532AA096DE8a3C4fEf9f875Bc55F);
IERC721 public erc721Address = IERC721(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 25; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 2000000000000000;
uint256 public limitHBWALLETFee = 2;
uint256 public hightLightFee = 30000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i = index; i<arrayTokenIdSale.length-1; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint[] memory arr) internal {
for(uint i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint256 _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
ethNeed = ethfee + _hightLightFee;
} else {
ethNeed = limitETHFee + _hightLightFee;
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable {
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee + _hightLightFee);
} else {
require(msg.value == limitETHFee + _hightLightFee);
ethfee = limitETHFee;
}
}
ethfee += prices[_tokenId].fee;
} else ethfee = _ethPrice * ETHFee / Percen;
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1 ? true : false);
}
function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint256 fee;
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
hbNeed = fee + _hightLightFee;
} else {
hbNeed = limitHBWALLETFee + _hightLightFee;
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public returns (bool){
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 fee;
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee + _hightLightFee));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee + _hightLightFee));
fee = limitHBWALLETFee;
}
}
fee += prices[_tokenId].hbfee;
} else {
ethfee = _ethPrice * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1 ? true : false);
return true;
}
function removePrice(uint256 tokenId) public returns (uint256){
require(erc721Address.ownerOf(tokenId) == msg.sender);
if (prices[tokenId].fee > 0) msg.sender.transfer(prices[tokenId].fee);
else if (prices[tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[tokenId].hbfee);
resetPrice(tokenId);
return prices[tokenId].price;
}
function setFee(uint256 _ethFee, uint256 _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint256, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint256 _hbWalletlimitFee) public onlyOwner returns (uint256, uint256){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(address payable _address, uint256 amount, uint256 _amountHB) internal {
require(_address != address(0) && amount >= 0 && address(this).balance >= amount && _amountHB >= 0 && hbwalletToken.balanceOf(address(this)) >= _amountHB);
_address.transfer(amount);
hbwalletToken.transferFrom(address(this), _address, _amountHB);
}
function withdraw(address payable _address, uint256 amount, uint256 _amountHB) public onlyCeoAddress {
_withdraw(_address, amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
uint256 eth = prices[arrayTokenIdSale[i]].fee;
if(prices[arrayTokenIdSale[i]].isHightlight == true) eth += hightLightFee;
if(address(this).balance >= eth) {
prices[arrayTokenIdSale[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
uint256 hb = prices[arrayTokenIdSale[i]].hbfee;
if(prices[arrayTokenIdSale[i]].isHightlight == true) hb += hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arrayTokenIdSale[i]].tokenOwner, hb);
}
}
}
}
_withdraw(msg.sender, address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view returns (uint256, uint256){
uint256 ethfee = 0;
uint256 hbfee = 0;
for (uint256 i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee += prices[arrayTokenIdSale[i]].fee;
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee += prices[arrayTokenIdSale[i]].hbfee;
}
}
}
uint256 eth = address(this).balance - ethfee;
uint256 hb = hbwalletToken.balanceOf(address(this)) - hbfee;
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint256 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
}
| 213,352 | 62 |
013bd89b02b9d9c440d42c81ef5c7d934859a1f6e9ed88c5d14cd1a5d7c7de33
| 27,439 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/33/33d43136960b62a2216bee8e5c5e54669b1a25bb_RoyaltyPaymentSplitter.sol
| 3,131 | 12,670 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity =0.8.17;
// OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return 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);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract PaymentSplitter is Context {
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
constructor(address[] memory payees, uint256[] memory shares_) payable {
require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
for (uint256 i = 0; i < payees.length; i++) {
_addPayee(payees[i], shares_[i]);
}
}
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function totalShares() public view returns (uint256) {
return _totalShares;
}
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
function totalReleased(IERC20 token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
function shares(address account) public view returns (uint256) {
return _shares[account];
}
function released(address account) public view returns (uint256) {
return _released[account];
}
function released(IERC20 token, address account) public view returns (uint256) {
return _erc20Released[token][account];
}
function payee(uint256 index) public view returns (address) {
return _payees[index];
}
function releasable(address account) public view returns (uint256) {
uint256 totalReceived = address(this).balance + totalReleased();
return _pendingPayment(account, totalReceived, released(account));
}
function releasable(IERC20 token, address account) public view returns (uint256) {
uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
return _pendingPayment(account, totalReceived, released(token, account));
}
function release(address payable account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 payment = releasable(account);
require(payment != 0, "PaymentSplitter: account is not due payment");
_released[account] += payment;
_totalReleased += payment;
Address.sendValue(account, payment);
emit PaymentReleased(account, payment);
}
function release(IERC20 token, address account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 payment = releasable(token, account);
require(payment != 0, "PaymentSplitter: account is not due payment");
_erc20Released[token][account] += payment;
_erc20TotalReleased[token] += payment;
SafeERC20.safeTransfer(token, account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
function _pendingPayment(address account,
uint256 totalReceived,
uint256 alreadyReleased) private view returns (uint256) {
return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
}
function _addPayee(address account, uint256 shares_) private {
require(account != address(0), "PaymentSplitter: account is the zero address");
require(shares_ > 0, "PaymentSplitter: shares are 0");
require(_shares[account] == 0, "PaymentSplitter: account already has shares");
_payees.push(account);
_shares[account] = shares_;
_totalShares = _totalShares + shares_;
emit PayeeAdded(account, shares_);
}
}
contract RoyaltyPaymentSplitter is PaymentSplitter {
uint256 _payeesCount;
constructor(address[] memory payees_, uint256[] memory shares_)
PaymentSplitter(payees_, shares_)
{
_payeesCount = payees_.length;
}
function releaseAll() external {
for (uint256 i = 0; i < _payeesCount; i++) {
address payee = super.payee(i);
super.release(payable(payee));
}
}
}
| 75,626 | 63 |
ac4adc4aa3cb2b2a79ae5de17f1c1945279c62ded2100b03bbb6ff181976c012
| 38,018 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xE89842aa086a893EdD76fB47488569474CAeE20D/contract.sol
| 4,856 | 19,072 |
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'));
}
}
// CakeToken with Governance.
contract CakeToken is BEP20('OmniSwap Token', 'OINK') {
/// @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
/// @dev A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 255,301 | 64 |
701de463bd96b3bff79f0dec411a3a88ec6c92cd42778622dc651865f6670faa
| 14,954 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xf07d979303c50a8632848cb154c6b30980218c07.sol
| 3,709 | 14,574 |
pragma solidity ^0.4.2;
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
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) public returns (bool success) {
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) public constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
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];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract PXLProperty is StandardToken {
uint8 constant LEVEL_1_MODERATOR = 1;
uint8 constant LEVEL_2_MODERATOR = 2;
uint8 constant LEVEL_1_ADMIN = 3;
uint8 constant LEVEL_2_ADMIN = 4;
uint8 constant LEVEL_1_ROOT = 5;
uint8 constant LEVEL_2_ROOT = 6;
uint8 constant LEVEL_3_ROOT = 7;
uint8 constant LEVEL_PROPERTY_DAPPS = 8;
uint8 constant LEVEL_PIXEL_PROPERTY = 9;
uint8 constant FLAG_NSFW = 1;
uint8 constant FLAG_BAN = 2;
address pixelPropertyContract;
mapping (address => uint8) public regulators;
mapping (uint16 => Property) public properties;
mapping (address => uint256[2]) public ownerWebsite;
mapping (address => uint256[2]) public ownerHoverText;
struct Property {
uint8 flag;
bool isInPrivateMode;
address owner;
address lastUpdater;
uint256[5] colors;
uint256 salePrice;
uint256 lastUpdate;
uint256 becomePublic;
uint256 earnUntil;
}
modifier regulatorAccess(uint8 accessLevel) {
require(accessLevel <= LEVEL_3_ROOT);
require(regulators[msg.sender] >= accessLevel);
if (accessLevel >= LEVEL_1_ADMIN) {
require(regulators[msg.sender] <= LEVEL_3_ROOT);
}
_;
}
modifier propertyDAppAccess() {
require(regulators[msg.sender] == LEVEL_PROPERTY_DAPPS || regulators[msg.sender] == LEVEL_PIXEL_PROPERTY);
_;
}
modifier pixelPropertyAccess() {
require(regulators[msg.sender] == LEVEL_PIXEL_PROPERTY);
_;
}
function PXLProperty() public {
regulators[msg.sender] = LEVEL_3_ROOT;
}
function setPropertyFlag(uint16 propertyID, uint8 flag) public regulatorAccess(flag == FLAG_NSFW ? LEVEL_1_MODERATOR : LEVEL_2_MODERATOR) {
properties[propertyID].flag = flag;
if (flag == FLAG_BAN) {
require(properties[propertyID].isInPrivateMode);
properties[propertyID].colors = [0, 0, 0, 0, 0];
}
}
function setRegulatorAccessLevel(address user, uint8 accessLevel) public regulatorAccess(LEVEL_1_ADMIN) {
if (msg.sender != user) {
require(regulators[msg.sender] > regulators[user]);
}
require(regulators[msg.sender] > accessLevel);
regulators[user] = accessLevel;
}
function setPixelPropertyContract(address newPixelPropertyContract) public regulatorAccess(LEVEL_2_ROOT) {
require(newPixelPropertyContract != 0);
if (pixelPropertyContract != 0) {
regulators[pixelPropertyContract] = 0;
}
pixelPropertyContract = newPixelPropertyContract;
regulators[newPixelPropertyContract] = LEVEL_PIXEL_PROPERTY;
}
function setPropertyDAppContract(address propertyDAppContract, bool giveAccess) public regulatorAccess(LEVEL_1_ROOT) {
require(propertyDAppContract != 0);
regulators[propertyDAppContract] = giveAccess ? LEVEL_PROPERTY_DAPPS : 0;
}
function setPropertyColors(uint16 propertyID, uint256[5] colors) public propertyDAppAccess() {
for(uint256 i = 0; i < 5; i++) {
if (properties[propertyID].colors[i] != colors[i]) {
properties[propertyID].colors[i] = colors[i];
}
}
}
function setPropertyRowColor(uint16 propertyID, uint8 row, uint256 rowColor) public propertyDAppAccess() {
if (properties[propertyID].colors[row] != rowColor) {
properties[propertyID].colors[row] = rowColor;
}
}
function setOwnerHoverText(address textOwner, uint256[2] hoverText) public propertyDAppAccess() {
require (textOwner != 0);
ownerHoverText[textOwner] = hoverText;
}
function setOwnerLink(address websiteOwner, uint256[2] website) public propertyDAppAccess() {
require (websiteOwner != 0);
ownerWebsite[websiteOwner] = website;
}
function setPropertyPrivateMode(uint16 propertyID, bool isInPrivateMode) public pixelPropertyAccess() {
if (properties[propertyID].isInPrivateMode != isInPrivateMode) {
properties[propertyID].isInPrivateMode = isInPrivateMode;
}
}
function setPropertyOwner(uint16 propertyID, address propertyOwner) public pixelPropertyAccess() {
if (properties[propertyID].owner != propertyOwner) {
properties[propertyID].owner = propertyOwner;
}
}
function setPropertyLastUpdater(uint16 propertyID, address lastUpdater) public pixelPropertyAccess() {
if (properties[propertyID].lastUpdater != lastUpdater) {
properties[propertyID].lastUpdater = lastUpdater;
}
}
function setPropertySalePrice(uint16 propertyID, uint256 salePrice) public pixelPropertyAccess() {
if (properties[propertyID].salePrice != salePrice) {
properties[propertyID].salePrice = salePrice;
}
}
function setPropertyLastUpdate(uint16 propertyID, uint256 lastUpdate) public pixelPropertyAccess() {
properties[propertyID].lastUpdate = lastUpdate;
}
function setPropertyBecomePublic(uint16 propertyID, uint256 becomePublic) public pixelPropertyAccess() {
properties[propertyID].becomePublic = becomePublic;
}
function setPropertyEarnUntil(uint16 propertyID, uint256 earnUntil) public pixelPropertyAccess() {
properties[propertyID].earnUntil = earnUntil;
}
function setPropertyPrivateModeEarnUntilLastUpdateBecomePublic(uint16 propertyID, bool privateMode, uint256 earnUntil, uint256 lastUpdate, uint256 becomePublic) public pixelPropertyAccess() {
if (properties[propertyID].isInPrivateMode != privateMode) {
properties[propertyID].isInPrivateMode = privateMode;
}
properties[propertyID].earnUntil = earnUntil;
properties[propertyID].lastUpdate = lastUpdate;
properties[propertyID].becomePublic = becomePublic;
}
function setPropertyLastUpdaterLastUpdate(uint16 propertyID, address lastUpdater, uint256 lastUpdate) public pixelPropertyAccess() {
if (properties[propertyID].lastUpdater != lastUpdater) {
properties[propertyID].lastUpdater = lastUpdater;
}
properties[propertyID].lastUpdate = lastUpdate;
}
function setPropertyBecomePublicEarnUntil(uint16 propertyID, uint256 becomePublic, uint256 earnUntil) public pixelPropertyAccess() {
properties[propertyID].becomePublic = becomePublic;
properties[propertyID].earnUntil = earnUntil;
}
function setPropertyOwnerSalePricePrivateModeFlag(uint16 propertyID, address owner, uint256 salePrice, bool privateMode, uint8 flag) public pixelPropertyAccess() {
if (properties[propertyID].owner != owner) {
properties[propertyID].owner = owner;
}
if (properties[propertyID].salePrice != salePrice) {
properties[propertyID].salePrice = salePrice;
}
if (properties[propertyID].isInPrivateMode != privateMode) {
properties[propertyID].isInPrivateMode = privateMode;
}
if (properties[propertyID].flag != flag) {
properties[propertyID].flag = flag;
}
}
function setPropertyOwnerSalePrice(uint16 propertyID, address owner, uint256 salePrice) public pixelPropertyAccess() {
if (properties[propertyID].owner != owner) {
properties[propertyID].owner = owner;
}
if (properties[propertyID].salePrice != salePrice) {
properties[propertyID].salePrice = salePrice;
}
}
function rewardPXL(address rewardedUser, uint256 amount) public pixelPropertyAccess() {
require(rewardedUser != 0);
balances[rewardedUser] += amount;
totalSupply += amount;
}
function burnPXL(address burningUser, uint256 amount) public pixelPropertyAccess() {
require(burningUser != 0);
require(balances[burningUser] >= amount);
balances[burningUser] -= amount;
totalSupply -= amount;
}
function burnPXLRewardPXL(address burner, uint256 toBurn, address rewarder, uint256 toReward) public pixelPropertyAccess() {
require(balances[burner] >= toBurn);
if (toBurn > 0) {
balances[burner] -= toBurn;
totalSupply -= toBurn;
}
if (rewarder != 0) {
balances[rewarder] += toReward;
totalSupply += toReward;
}
}
function burnPXLRewardPXLx2(address burner, uint256 toBurn, address rewarder1, uint256 toReward1, address rewarder2, uint256 toReward2) public pixelPropertyAccess() {
require(balances[burner] >= toBurn);
if (toBurn > 0) {
balances[burner] -= toBurn;
totalSupply -= toBurn;
}
if (rewarder1 != 0) {
balances[rewarder1] += toReward1;
totalSupply += toReward1;
}
if (rewarder2 != 0) {
balances[rewarder2] += toReward2;
totalSupply += toReward2;
}
}
function getOwnerHoverText(address user) public view returns(uint256[2]) {
return ownerHoverText[user];
}
function getOwnerLink(address user) public view returns(uint256[2]) {
return ownerWebsite[user];
}
function getPropertyFlag(uint16 propertyID) public view returns(uint8) {
return properties[propertyID].flag;
}
function getPropertyPrivateMode(uint16 propertyID) public view returns(bool) {
return properties[propertyID].isInPrivateMode;
}
function getPropertyOwner(uint16 propertyID) public view returns(address) {
return properties[propertyID].owner;
}
function getPropertyLastUpdater(uint16 propertyID) public view returns(address) {
return properties[propertyID].lastUpdater;
}
function getPropertyColors(uint16 propertyID) public view returns(uint256[5]) {
return properties[propertyID].colors;
}
function getPropertyColorsOfRow(uint16 propertyID, uint8 rowIndex) public view returns(uint256) {
require(rowIndex <= 9);
return properties[propertyID].colors[rowIndex];
}
function getPropertySalePrice(uint16 propertyID) public view returns(uint256) {
return properties[propertyID].salePrice;
}
function getPropertyLastUpdate(uint16 propertyID) public view returns(uint256) {
return properties[propertyID].lastUpdate;
}
function getPropertyBecomePublic(uint16 propertyID) public view returns(uint256) {
return properties[propertyID].becomePublic;
}
function getPropertyEarnUntil(uint16 propertyID) public view returns(uint256) {
return properties[propertyID].earnUntil;
}
function getRegulatorLevel(address user) public view returns(uint8) {
return regulators[user];
}
function getPropertyData(uint16 propertyID, uint256 systemSalePriceETH, uint256 systemSalePricePXL) public view returns(address, uint256, uint256, uint256, bool, uint256, uint8) {
Property memory property = properties[propertyID];
bool isInPrivateMode = property.isInPrivateMode;
if (isInPrivateMode && property.becomePublic <= now) {
isInPrivateMode = false;
}
if (properties[propertyID].owner == 0) {
return (0, systemSalePriceETH, systemSalePricePXL, property.lastUpdate, isInPrivateMode, property.becomePublic, property.flag);
} else {
return (property.owner, 0, property.salePrice, property.lastUpdate, isInPrivateMode, property.becomePublic, property.flag);
}
}
function getPropertyPrivateModeBecomePublic(uint16 propertyID) public view returns (bool, uint256) {
return (properties[propertyID].isInPrivateMode, properties[propertyID].becomePublic);
}
function getPropertyLastUpdaterBecomePublic(uint16 propertyID) public view returns (address, uint256) {
return (properties[propertyID].lastUpdater, properties[propertyID].becomePublic);
}
function getPropertyOwnerSalePrice(uint16 propertyID) public view returns (address, uint256) {
return (properties[propertyID].owner, properties[propertyID].salePrice);
}
function getPropertyPrivateModeLastUpdateEarnUntil(uint16 propertyID) public view returns (bool, uint256, uint256) {
return (properties[propertyID].isInPrivateMode, properties[propertyID].lastUpdate, properties[propertyID].earnUntil);
}
}
| 161,198 | 65 |
512420108a429c79a600f57d94f1332582fa87080afa76ca9425a65bf0d9b127
| 10,402 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaa10481f5d50ab16355f17ab3fb5309f2ac68037.sol
| 2,727 | 10,179 |
pragma solidity ^0.4.25;
// 'GadiunTrustWallet'
//
// NAME : Gadiun Trust Wallet
// Symbol : GTW
// Total supply: 8,000,000,000
// Decimals : 8
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract GadiunTrustWallet is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Gadiun Trust Wallet";
string public constant symbol = "GTW";
uint public constant decimals = 8;
uint public deadline = now + 35 * 1 days;
uint public round2 = now + 30 * 1 days;
uint public round1 = now + 20 * 1 days;
uint256 public totalSupply = 8000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 10000000e8;
uint public target0drop = 20000;
uint public progress0drop = 0;
address multisig = 0xcC88CFb66aC41d7884f803A938F7852ee85126f1;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 3500000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 2;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 3 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 7000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 203,246 | 66 |
1e4f5230e9bde626349e7f52148cee723375db9ed4aa17f38edfb0c3fadfc8ff
| 9,643 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x0debfb5127d8b5dd2fafc93724c88bd7f40cc852.sol
| 3,145 | 9,290 |
pragma solidity ^0.4.25;
interface DSG {
function gamingDividendsReception() payable external;
}
contract DSG_Turntable{
using SafeMath for uint256;
address constant public DSG_ADDRESS = 0x696826C18A6Bc9Be4BBfe3c3A6BB9f5a69388687;
uint256 public totalDividends;
uint256 public totalWinnings;
uint256 public totalTurnover;
uint256 public totalPlayed;
uint256 public maxBet;
uint256 public minBet;
uint256 public minContractBalance;
uint256 public minBetForJackpot;
uint256 public jackpotBalance;
uint256 public nextPayout;
uint256 public ownerDeposit;
address[2] public owners;
address[2] public candidates;
bool public paused;
mapping (address => Bet) private usersBets;
struct Bet {
uint256 blockNumber;
uint256 bet;
}
modifier onlyOwners(){
require(msg.sender == owners[0] || msg.sender == owners[1]);
_;
}
modifier onlyUsers(){
require(tx.origin == msg.sender);
_;
}
modifier checkBlockNumber(){
uint256 blockNumber = usersBets[msg.sender].blockNumber;
if(block.number.sub(blockNumber) >= 250 && blockNumber > 0){
emit Result(msg.sender, 1000, 0, jackpotBalance, usersBets[msg.sender].bet, 0);
delete usersBets[msg.sender];
}
else{
_;
}
}
constructor(address secondOwner) public payable{
owners[0] = msg.sender;
owners[1] = secondOwner;
ownerDeposit = msg.value;
jackpotBalance = jackpotBalance.add(ownerDeposit.div(1000));
}
function play() public payable checkBlockNumber onlyUsers{
uint256 bet = msg.value;
require(checkSolvency(bet), "Not enough ETH in contract");
require(paused == false, "Game was stopped");
require(bet >= minBet && bet <= maxBet, "Amount should be within range");
require(usersBets[msg.sender].bet == 0, "You have already bet");
usersBets[msg.sender].bet = bet;
usersBets[msg.sender].blockNumber = block.number;
totalTurnover = totalTurnover.add(bet);
totalPlayed = totalPlayed.add(1);
emit PlaceBet(msg.sender, bet, now);
}
function result() public checkBlockNumber onlyUsers{
require(blockhash(usersBets[msg.sender].blockNumber) != 0, "Your time to determine the result has come out or not yet come");
uint256 bet = usersBets[msg.sender].bet;
uint256 totalWinAmount;
uint256 r = _random(1000);
uint256 winRate = 0;
if(_winChanceJ(r, bet)){
winRate = 1000;
totalWinAmount = totalWinAmount.add(jackpotBalance);
emit Jackpot(msg.sender, jackpotBalance, now);
delete jackpotBalance;
}
if(_winChance1x(r)){
winRate = 100;
totalWinAmount = totalWinAmount.add(bet);
}
if(_winChance1_5x(r)){
winRate = 150;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2x(r)){
winRate = 200;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2_5x(r)){
winRate = 250;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance3x(r)){
winRate = 300;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance5x(r)){
winRate = 500;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(totalWinAmount > 0){
msg.sender.transfer(totalWinAmount);
totalWinnings = totalWinnings.add(totalWinAmount);
}
jackpotBalance = jackpotBalance.add(bet.div(1000));
delete usersBets[msg.sender];
emit Result(msg.sender, r, totalWinAmount, jackpotBalance, bet, winRate);
}
function _winChanceJ(uint r, uint bet) private view returns(bool){
if(bet >= minBetForJackpot && r == 999 && jackpotBalance > 0) return true;
else return false;
}
function _winChance5x(uint r) private pure returns(bool){
if(r == 11 || r == 21 || r == 31 || r == 41 || r == 51 || r == 61 || r == 71 || r == 81 || r == 91 || r == 99) return true;
else return false;
}
function _winChance3x(uint r) private pure returns(bool){
if((r >= 80 && r < 83) ||
(r >= 180 && r < 183) ||
(r >= 280 && r < 283) ||
(r >= 380 && r < 383) ||
(r >= 480 && r < 483) ||
(r >= 580 && r < 583) ||
(r >= 680 && r < 683) ||
(r >= 780 && r < 783) ||
(r >= 880 && r < 883) ||
(r >= 980 && r < 983))
return true;
else return false;
}
function _winChance2_5x(uint r) private pure returns(bool){
if((r >= 75 && r < 80) ||
(r >= 175 && r < 180) ||
(r >= 275 && r < 280) ||
(r >= 375 && r < 380) ||
(r >= 475 && r < 480) ||
(r >= 575 && r < 580) ||
(r >= 675 && r < 680) ||
(r >= 775 && r < 780) ||
(r >= 875 && r < 880) ||
(r >= 975 && r < 980))
return true;
else return false;
}
function _winChance2x(uint r) private pure returns(bool){
if((r >= 50 && r < 75) || (r >= 350 && r < 375) || (r >= 650 && r < 675) || (r >= 950 && r < 975)) return true;
else return false;
}
function _winChance1_5x(uint r) private pure returns(bool){
if((r >= 25 && r < 50) || (r >= 125 && r < 150)) return true;
else if((r >= 425 && r < 450) || (r >= 525 && r < 550)) return true;
else if((r >= 625 && r < 650) || (r >= 725 && r < 750)) return true;
else return false;
}
function _winChance1x(uint r) private pure returns(bool){
if((r >= 0 && r < 25) || (r >= 100 && r < 125)) return true;
else if((r >= 400 && r < 425) || (r >= 500 && r < 525)) return true;
else if((r >= 600 && r < 625) || (r >= 700 && r < 725)) return true;
else if((r >= 800 && r < 825) || (r >= 900 && r < 925)) return true;
else return false;
}
function checkSolvency(uint bet) view public returns(bool){
if(getContractBalance() > bet.mul(500).div(100).add(jackpotBalance)) return true;
else return false;
}
function sendDividends() public {
require(getContractBalance() > minContractBalance && now > nextPayout, "You cannot send dividends");
DSG DSG0 = DSG(DSG_ADDRESS);
uint256 balance = getContractBalance();
uint256 dividends = balance.sub(minContractBalance);
nextPayout = now.add(7 days);
totalDividends = totalDividends.add(dividends);
DSG0.gamingDividendsReception.value(dividends)();
emit Dividends(balance, dividends, now);
}
function getContractBalance() public view returns (uint256){
return address(this).balance;
}
function _random(uint256 max) private view returns(uint256){
bytes32 hash = blockhash(usersBets[msg.sender].blockNumber);
return uint256(keccak256(abi.encode(hash, msg.sender))) % max;
}
function deposit() public payable onlyOwners{
ownerDeposit = ownerDeposit.add(msg.value);
}
function sendOwnerDeposit(address recipient) public onlyOwners{
require(paused == true, 'Game was not stopped');
uint256 contractBalance = getContractBalance();
if(contractBalance >= ownerDeposit){
recipient.transfer(ownerDeposit);
}
else{
recipient.transfer(contractBalance);
}
delete jackpotBalance;
delete ownerDeposit;
}
function pauseGame(bool option) public onlyOwners{
paused = option;
}
function setMinBet(uint256 eth) public onlyOwners{
minBet = eth;
}
function setMaxBet(uint256 eth) public onlyOwners{
maxBet = eth;
}
function setMinBetForJackpot(uint256 eth) public onlyOwners{
minBetForJackpot = eth;
}
function setMinContractBalance(uint256 eth) public onlyOwners{
minContractBalance = eth;
}
function transferOwnership(address newOwnerAddress, uint8 k) public onlyOwners{
candidates[k] = newOwnerAddress;
}
function confirmOwner(uint8 k) public{
require(msg.sender == candidates[k]);
owners[k] = candidates[k];
}
event Dividends(uint256 balance,
uint256 dividends,
uint256 timestamp);
event Jackpot(address indexed player,
uint256 jackpot,
uint256 timestamp);
event PlaceBet(address indexed player,
uint256 bet,
uint256 timestamp);
event Result(address indexed player,
uint256 indexed random,
uint256 totalWinAmount,
uint256 jackpotBalance,
uint256 bet,
uint256 winRate);
}
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;
}
}
| 140,519 | 67 |
e21880c1d6ba2ccaf3c31aafa83766325eb0071548fe96682a63fdfb580e5f4d
| 21,503 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5d/5dfF474Cea8A1FA929AC9A3cE2550376aF11d2A8_Fraxferry.sol
| 4,097 | 15,515 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;
// Sources flattened with hardhat v2.12.0 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// File @openzeppelin/contracts/token/ERC20/extensions/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// File @uniswap/v3-periphery/contracts/libraries/[emailprotected]
library TransferHelper {
/// @notice Transfers tokens from the targeted address to the given destination
/// @notice Errors with 'STF' if transfer fails
/// @param token The contract address of the token to be transferred
/// @param from The originating address from which the tokens will be transferred
/// @param to The destination address of the transfer
/// @param value The amount to be transferred
function safeTransferFrom(address token,
address from,
address to,
uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
/// @notice Transfers tokens from msg.sender to a recipient
/// @dev Errors with ST if transfer fails
/// @param token The contract address of the token which will be transferred
/// @param to The recipient of the transfer
/// @param value The value of the transfer
function safeTransfer(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
/// @notice Approves the stipulated contract to spend the given allowance in the given token
/// @dev Errors with 'SA' if transfer fails
/// @param token The contract address of the token to be approved
/// @param to The target of the approval
/// @param value The amount of the given token the target will be allowed to spend
function safeApprove(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
}
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
(bool success,) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}
// File contracts/Fraxferry/Fraxferry.sol
// ====================================================================
// | ______ _______ |
// | / _____________ __ __ / ____(_____ ____ _____ ________ |
// | / /_ / ___/ __ `| |/_/ / /_ / / __ \/ __ `/ __ \/ ___/ _ \ |
// | / __/ / / / /_/ _> < / __/ / / / / / /_/ / / / / /__/ __/ |
// | /_/ /_/ \__,_/_/|_| /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/ |
// | |
// ====================================================================
// ============================ Fraxferry =============================
// ====================================================================
// Ferry that can be used to ship tokens between chains
// Frax Finance: https://github.com/FraxFinance
// Primary Author(s)
// Dennis: https://github.com/denett
contract Fraxferry {
IERC20 immutable public token;
IERC20 immutable public targetToken;
uint immutable public chainid;
uint immutable public targetChain;
address public owner;
address public nominatedOwner;
address public captain;
address public firstOfficer;
mapping(address => bool) public crewmembers;
bool public paused;
uint public MIN_WAIT_PERIOD_ADD=3600; // Minimal 1 hour waiting
uint public MIN_WAIT_PERIOD_EXECUTE=82800; // Minimal 23 hour waiting
uint public FEE=1*1e18; // 1 token
uint immutable MAX_FEE=100e18; // Max fee is 100 tokens
uint immutable public REDUCED_DECIMALS=1e10;
Transaction[] public transactions;
mapping(uint => bool) public cancelled;
uint public executeIndex;
Batch[] public batches;
struct Transaction {
address user;
uint64 amount;
uint32 timestamp;
}
struct Batch {
uint64 start;
uint64 end;
uint64 departureTime;
uint64 status;
bytes32 hash;
}
struct BatchData {
uint startTransactionNo;
Transaction[] transactions;
}
constructor(IERC20 _token, uint _chainid, IERC20 _targetToken, uint _targetChain) {
//require (block.chainid==_chainid,"Wrong chain");
chainid=_chainid;
token = _token;
targetToken = _targetToken;
owner = msg.sender;
targetChain = _targetChain;
}
// ############## Events ##############
event Embark(address indexed sender, uint index, uint amount, uint amountAfterFee, uint timestamp);
event Disembark(uint start, uint end, bytes32 hash);
event Depart(uint batchNo,uint start,uint end,bytes32 hash);
event RemoveBatch(uint batchNo);
event DisputeBatch(uint batchNo, bytes32 hash);
event Cancelled(uint index, bool cancel);
event Pause(bool paused);
event OwnerNominated(address indexed newOwner);
event OwnerChanged(address indexed previousOwner,address indexed newOwner);
event SetCaptain(address indexed previousCaptain, address indexed newCaptain);
event SetFirstOfficer(address indexed previousFirstOfficer, address indexed newFirstOfficer);
event SetCrewmember(address indexed crewmember,bool set);
event SetFee(uint previousFee, uint fee);
event SetMinWaitPeriods(uint previousMinWaitAdd,uint previousMinWaitExecute,uint minWaitAdd,uint minWaitExecute);
// ############## Modifiers ##############
modifier isOwner() {
require (msg.sender==owner,"Not owner");
_;
}
modifier isCaptain() {
require (msg.sender==captain,"Not captain");
_;
}
modifier isFirstOfficer() {
require (msg.sender==firstOfficer,"Not first officer");
_;
}
modifier isCrewmember() {
require (crewmembers[msg.sender] || msg.sender==owner || msg.sender==captain || msg.sender==firstOfficer,"Not crewmember");
_;
}
modifier notPaused() {
require (!paused,"Paused");
_;
}
// ############## Ferry actions ##############
function embarkWithRecipient(uint amount, address recipient) public notPaused {
amount = (amount/REDUCED_DECIMALS)*REDUCED_DECIMALS; // Round amount to fit in data structure
require (amount>FEE,"Amount too low");
require (amount/REDUCED_DECIMALS<=type(uint64).max,"Amount too high");
TransferHelper.safeTransferFrom(address(token),msg.sender,address(this),amount);
uint64 amountAfterFee = uint64((amount-FEE)/REDUCED_DECIMALS);
emit Embark(recipient,transactions.length,amount,amountAfterFee*REDUCED_DECIMALS,block.timestamp);
transactions.push(Transaction(recipient,amountAfterFee,uint32(block.timestamp)));
}
function embark(uint amount) public {
embarkWithRecipient(amount, msg.sender) ;
}
function embarkWithSignature(uint256 _amount,
address recipient,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) public {
uint amount = approveMax ? type(uint256).max : _amount;
IERC20Permit(address(token)).permit(msg.sender, address(this), amount, deadline, v, r, s);
embarkWithRecipient(amount,recipient);
}
function depart(uint start, uint end, bytes32 hash) external notPaused isCaptain {
require ((batches.length==0 && start==0) || (batches.length>0 && start==batches[batches.length-1].end+1),"Wrong start");
require (end>=start && end<type(uint64).max,"Wrong end");
batches.push(Batch(uint64(start),uint64(end),uint64(block.timestamp),0,hash));
emit Depart(batches.length-1,start,end,hash);
}
function disembark(BatchData calldata batchData) external notPaused isFirstOfficer {
Batch memory batch = batches[executeIndex++];
require (batch.status==0,"Batch disputed");
require (batch.start==batchData.startTransactionNo,"Wrong start");
require (batch.start+batchData.transactions.length-1==batch.end,"Wrong size");
require (block.timestamp-batch.departureTime>=MIN_WAIT_PERIOD_EXECUTE,"Too soon");
bytes32 hash = keccak256(abi.encodePacked(targetChain, targetToken, chainid, token, batch.start));
for (uint i=0;i<batchData.transactions.length;++i) {
if (!cancelled[batch.start+i]) {
TransferHelper.safeTransfer(address(token),batchData.transactions[i].user,batchData.transactions[i].amount*REDUCED_DECIMALS);
}
hash = keccak256(abi.encodePacked(hash, batchData.transactions[i].user,batchData.transactions[i].amount));
}
require (batch.hash==hash,"Wrong hash");
emit Disembark(batch.start,batch.end,hash);
}
function removeBatches(uint batchNo) external isOwner {
require (executeIndex<=batchNo,"Batch already executed");
while (batches.length>batchNo) batches.pop();
emit RemoveBatch(batchNo);
}
function disputeBatch(uint batchNo, bytes32 hash) external isCrewmember {
require (batches[batchNo].hash==hash,"Wrong hash");
require (executeIndex<=batchNo,"Batch already executed");
require (batches[batchNo].status==0,"Batch already disputed");
batches[batchNo].status=1; // Set status on disputed
_pause(true);
emit DisputeBatch(batchNo,hash);
}
function pause() external isCrewmember {
_pause(true);
}
function unPause() external isOwner {
_pause(false);
}
function _pause(bool _paused) internal {
paused=_paused;
emit Pause(_paused);
}
function _jettison(uint index, bool cancel) internal {
require (executeIndex==0 || index>batches[executeIndex-1].end,"Transaction already executed");
cancelled[index]=cancel;
emit Cancelled(index,cancel);
}
function jettison(uint index, bool cancel) external isOwner {
_jettison(index,cancel);
}
function jettisonGroup(uint[] calldata indexes, bool cancel) external isOwner {
for (uint i=0;i<indexes.length;++i) {
_jettison(indexes[i],cancel);
}
}
// ############## Parameters management ##############
function setFee(uint _FEE) external isOwner {
require(FEE<MAX_FEE);
emit SetFee(FEE,_FEE);
FEE=_FEE;
}
function setMinWaitPeriods(uint _MIN_WAIT_PERIOD_ADD, uint _MIN_WAIT_PERIOD_EXECUTE) external isOwner {
require(_MIN_WAIT_PERIOD_ADD>=3600 && _MIN_WAIT_PERIOD_EXECUTE>=3600,"Period too short");
emit SetMinWaitPeriods(MIN_WAIT_PERIOD_ADD, MIN_WAIT_PERIOD_EXECUTE,_MIN_WAIT_PERIOD_ADD, _MIN_WAIT_PERIOD_EXECUTE);
MIN_WAIT_PERIOD_ADD=_MIN_WAIT_PERIOD_ADD;
MIN_WAIT_PERIOD_EXECUTE=_MIN_WAIT_PERIOD_EXECUTE;
}
// ############## Roles management ##############
function nominateNewOwner(address newOwner) external isOwner {
nominatedOwner = newOwner;
emit OwnerNominated(newOwner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
function setCaptain(address newCaptain) external isOwner {
emit SetCaptain(captain,newCaptain);
captain=newCaptain;
}
function setFirstOfficer(address newFirstOfficer) external isOwner {
emit SetFirstOfficer(firstOfficer,newFirstOfficer);
firstOfficer=newFirstOfficer;
}
function setCrewmember(address crewmember, bool set) external isOwner {
crewmembers[crewmember]=set;
emit SetCrewmember(crewmember,set);
}
// ############## Token management ##############
function sendTokens(address receiver, uint amount) external isOwner {
require (receiver!=address(0),"Zero address not allowed");
TransferHelper.safeTransfer(address(token),receiver,amount);
}
// Generic proxy
function execute(address _to, uint256 _value, bytes calldata _data) external isOwner returns (bool, bytes memory) {
require(_data.length==0 || _to.code.length>0,"Can not call a function on a EOA");
(bool success, bytes memory result) = _to.call{value:_value}(_data);
return (success, result);
}
// ############## Views ##############
function getNextBatch(uint _start, uint max) public view returns (uint start, uint end, bytes32 hash) {
uint cutoffTime = block.timestamp-MIN_WAIT_PERIOD_ADD;
if (_start<transactions.length && transactions[_start].timestamp<cutoffTime) {
start=_start;
end=start+max-1;
if (end>=transactions.length) end=transactions.length-1;
while(transactions[end].timestamp>=cutoffTime) end--;
hash = getTransactionsHash(start,end);
}
}
function getBatchData(uint start, uint end) public view returns (BatchData memory data) {
data.startTransactionNo = start;
data.transactions = new Transaction[](end-start+1);
for (uint i=start;i<=end;++i) {
data.transactions[i-start]=transactions[i];
}
}
function getBatchAmount(uint start, uint end) public view returns (uint totalAmount) {
for (uint i=start;i<=end;++i) {
totalAmount+=transactions[i].amount;
}
totalAmount*=REDUCED_DECIMALS;
}
function getTransactionsHash(uint start, uint end) public view returns (bytes32) {
bytes32 result = keccak256(abi.encodePacked(chainid, token, targetChain, targetToken, uint64(start)));
for (uint i=start;i<=end;++i) {
result = keccak256(abi.encodePacked(result, transactions[i].user,transactions[i].amount));
}
return result;
}
function noTransactions() public view returns (uint) {
return transactions.length;
}
function noBatches() public view returns (uint) {
return batches.length;
}
}
| 82,839 | 68 |
6cd9382c772d28f718792ce1ce35a1108220e0bcd31c06d6fe5875c1b4ce3679
| 33,207 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/56/569D7b2Af1D97014B3e5970E0bd1119B2a609d6D_ProxyAdmin.sol
| 3,531 | 14,793 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback () external payable virtual {
_fallback();
}
receive () external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {
}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ProxyAdmin is Ownable {
function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
| 124,261 | 69 |
04c98806cf71bf001a1086a7dcd47b1370ff8276c9958752fba3fa9fa299407b
| 27,105 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8c/8c84a5f5ae706d99720e9e053581b9318583af26_PopeyeSwapper.sol
| 3,875 | 14,758 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library 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");
}
}
}
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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract PopeyeSwapper is Operator {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public tomb;
IERC20 public tbond;
IERC20 public tshare;
address public tombSpookyLpPair;
address public tshareSpookyLpPair;
address public wftmAddress;
address public daoAddress;
event TBondSwapPerformed(address indexed sender, uint256 tbondAmount, uint256 tshareAmount);
constructor(address _tomb,
address _tbond,
address _tshare,
address _wftmAddress,
address _tombSpookyLpPair,
address _tshareSpookyLpPair,
address _daoAddress) public {
tomb = IERC20(_tomb);
tbond = IERC20(_tbond);
tshare = IERC20(_tshare);
wftmAddress = _wftmAddress;
tombSpookyLpPair = _tombSpookyLpPair;
tshareSpookyLpPair = _tshareSpookyLpPair;
daoAddress = _daoAddress;
}
modifier isSwappable() {
//TODO: What is a good number here?
require(tomb.totalSupply() >= 60 ether, "ChipSwapMechanismV2.isSwappable(): Insufficient supply.");
_;
}
function estimateAmountOfTShare(uint256 _tbondAmount) external view returns (uint256) {
uint256 tshareAmountPerTomb = getTShareAmountPerTomb();
return _tbondAmount.mul(tshareAmountPerTomb).div(1e18);
}
function swapTBondToTShare(uint256 _tbondAmount) external {
require(getTBondBalance(msg.sender) >= _tbondAmount, "Not enough SHERIFF in wallet");
uint256 tshareAmountPerTomb = getTShareAmountPerTomb();
uint256 tshareAmount = _tbondAmount.mul(tshareAmountPerTomb).div(1e18);
require(getTShareBalance() >= tshareAmount, "Not enough COWBOY.");
tbond.safeTransferFrom(msg.sender, daoAddress, _tbondAmount);
tshare.safeTransfer(msg.sender, tshareAmount);
emit TBondSwapPerformed(msg.sender, _tbondAmount, tshareAmount);
}
function withdrawTShare(uint256 _amount) external onlyOperator {
require(getTShareBalance() >= _amount, "ChipSwapMechanism.withdrawFish(): Insufficient FISH balance.");
tshare.safeTransfer(msg.sender, _amount);
}
function getTShareBalance() public view returns (uint256) {
return tshare.balanceOf(address(this));
}
function getTBondBalance(address _user) public view returns (uint256) {
return tbond.balanceOf(_user);
}
function getTombPrice() public view returns (uint256) {
return IERC20(wftmAddress).balanceOf(tombSpookyLpPair)
.mul(1e18)
.div(tomb.balanceOf(tombSpookyLpPair));
}
function getTSharePrice() public view returns (uint256) {
return IERC20(wftmAddress).balanceOf(tshareSpookyLpPair)
.mul(1e18)
.div(tshare.balanceOf(tshareSpookyLpPair));
}
function getTShareAmountPerTomb() public view returns (uint256) {
uint256 tombPrice = IERC20(wftmAddress).balanceOf(tombSpookyLpPair)
.mul(1e18)
.div(tomb.balanceOf(tombSpookyLpPair));
uint256 tsharePrice =
IERC20(wftmAddress).balanceOf(tshareSpookyLpPair)
.mul(1e18)
.div(tshare.balanceOf(tshareSpookyLpPair));
return tombPrice.mul(1e18).div(tsharePrice);
}
}
| 307,572 | 70 |
40a4bb809ed98d459aacc5da40cf5bed1610f1574d9839f491002c87e3be49a9
| 29,525 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/37/3794F101Cdff021b1B734E6f15786234bcA67f4B_RaidsFinance.sol
| 5,192 | 18,705 |
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 RaidsFinance 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 = 'Raids Finance';
string private constant _symbol = 'RAID';
uint256 private _taxFee = 400;
uint256 private _burnFee = 200;
uint public max_tx_size = 100000000 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 != 0x467015E76A65A613CA195C1C03AD769e09a9CeC1, '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;
}
}
| 316,068 | 71 |
588153b7c432ac1bf0c50f1d61f652c72be45987cc89cb6017d5480920b05407
| 11,038 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x33f00114d5aca3dee03189d4ed9d4f886dad84b0.sol
| 3,595 | 10,909 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// PROOF OF STEEL HANDS Version, 10% Fee on Purchase and Sell
contract PonziToken {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 50%
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.5ether and price 1 ether/token.
// stop being a memelord no this does not mean only 50% of people can cash out
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "POWHShadow";
string constant public symbol = "PWHS";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function PonziToken() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
selfdestruct(0x945C84b2FdD331ed3E8e7865E830626e6CeFAB94);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 10 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// 10% of the amount is used to reward HODLers
// Not you, Mr Sellout
// That's what you get for being weak handed
var fee = (uint)(msg.value / 10);
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
// Fee is distributed to all existing tokens after selling
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 209,712 | 72 |
2f00fa70c9a8bf7c6f5f93baeda08c1cc7be6a285339f2348527f29761e12e06
| 19,251 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x638e6355e9061e7c28ea5a0f96953922247b2896.sol
| 9,315 | 16,085 |
pragma solidity ^0.4.21 ;
contract RE_Portfolio_I_883 {
mapping (address => uint256) public balanceOf;
string public name = " RE_Portfolio_I_883 " ;
string public symbol = " RE883I " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1591676265575320000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_I_metadata_line_1_____AA_Euler_Hermes_SA_AAm_20250515 >
// < MGR3m39Pcxxd38Tw15eOSc39puzA1XdnMjO1JHMf02oDPoLqwPr22COs40XkOvAt >
// < 1E-018 limites [ 1E-018 ; 23466777,8761341 ] >
// < 0x000000000000000000000000000000000000000000000000000000008BDF780F >
// < RE_Portfolio_I_metadata_line_2_____AA_Euler_Hermes_SA_AAm_20250515 >
// < 14uzr4et42wJvn10409D50cNoG5ATiJYs1gG2UdU9Pk0rzU7se3540s6BZVu2h41 >
// < 1E-018 limites [ 23466777,8761341 ; 37807926,3543451 ] >
// < 0x0000000000000000000000000000000000000000000000008BDF780FE15A532F >
// < 54ARHxYNL41UCnnZb6B3h2bVq2qJXGuHo3EtaO78elTemh7NFet0oNmsmiEUQ8FK >
// < 1E-018 limites [ 37807926,3543451 ; 73081950,0897789 ] >
// < 0x00000000000000000000000000000000000000000000000E15A532F1B39A36B4 >
// < RE_Portfolio_I_metadata_line_7_____Ace_Group_of_Companies_20250515 >
// < MGR3m39Pcxxd38Tw15eOSc39puzA1XdnMjO1JHMf02oDPoLqwPr22COs40XkOvAt >
// < 1E-018 limites [ 73081950,0897789 ; 134176053,834668 ] >
// < 0x00000000000000000000000000000000000000000000001B39A36B431FC06AFB >
// < RE_Portfolio_I_metadata_line_8_____Ace_Group_of_Companies_20250515 >
// < I69v5ClJ4b14E3l6RfmXqI8035jUy46Qc7lNQhL7B80LQ8ZZ5phVPAxe4laZyyn0 >
// < 1E-018 limites [ 277969870,344396 ; 294602007,09604 ] >
// < 0x000000000000000000000000000000000000000000000031FC06AFB44E3A6C93 >
// < RE_Portfolio_I_metadata_line_6_____ACE_European_Group_Limited_AA_App_20250515 >
// < uirf25wA9t6VuCEU796GMdLF8wIQfnoe58yp6cWocsg4Ajphu3RK3wZFT6qnY6Xu >
// < 1E-018 limites [ 294602007,09604 ; 328167666,886427 ] >
// < 0x000000000000000000000000000000000000000000000044E3A6C9361C5B96C1 >
// < 89SsNu3CC9Qm4FTp1kDah1Aq0MU9WAADyG9ZuC0LsgMp3oD2Q8r6HVHs4Yzkd8Cy >
// < 1E-018 limites [ 328167666,886427 ; 388131600,02045 ] >
// < 0x000000000000000000000000000000000000000000000061C5B96C1678D45E8E >
// < RE_Portfolio_I_metadata_line_8_____Ace_Group_of_Companies_20250515 >
// < 5yuBsTtVr0Z2CDm4BcxDFZjk4BOT71d5dqd37aFqodjtHwXa59Nk7GB84GYKBB3B >
// < 1E-018 limites [ 277969870,344396 ; 294602007,09604 ] >
// < 0x0000000000000000000000000000000000000000000000678D45E8E6DBF6FEF9 >
// < RE_Portfolio_I_metadata_line_9_____ACE_Limited_20250515 >
// < h42QuYHXTu84f30rMj56ozR6nz0dHs3MkU2L12v1jcN21XEYEPeg1q42YcP38H88 >
// < 1E-018 limites [ 294602007,09604 ; 328167666,886427 ] >
// < 0x00000000000000000000000000000000000000000000006DBF6FEF97A40820D4 >
// < SACtV58n2y34TUl56K58ISbV82AS3hJO5CLtS2N0lGk9ep2v28YvGl4O3cltv91h >
// < 1E-018 limites [ 328167666,886427 ; 388131600,02045 ] >
// < 0x00000000000000000000000000000000000000000000007A40820D490971D436 >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_I_metadata_line_11_____ACE_Tempest_Reinsurance_Limited_20250515 >
// < 5VbH9L78M031ns1O5VbtzcQ8hrUI7q68arlr6O1m3y4eh0K5hghs0a3PW31jk74F >
// < 1E-018 limites [ 388131600,02045 ; 415184250,130549 ] >
// < 0x000000000000000000000000000000000000000000000090971D4369AAB0E5A9 >
// < RE_Portfolio_I_metadata_line_12_____ACE_Tempest_Reinsurance_Limited_20250515 >
// < efrCS1gj7F73u81xfD3x49jzpV4pd7AmARTQ7j222sWEO5tq6QH0vPaqAErZT4R1 >
// < 1E-018 limites [ 415184250,130549 ; 451109181,358069 ] >
// < 0x00000000000000000000000000000000000000000000009AAB0E5A9A80D1FDEB >
// < RE_Portfolio_I_metadata_line_13_____Ace_Underwriting_Agencies_Limited_20250515 >
// < QQ2HA8Vmr4fVf6W1ZR8cH8w95rM7FsVZq6844bB0RLhJr016n58zAJ84qx3Q30oa >
// < 1E-018 limites [ 451109181,358069 ; 507141771,80459 ] >
// < 0x0000000000000000000000000000000000000000000000A80D1FDEBBCECCF090 >
// < RE_Portfolio_I_metadata_line_14_____ACR_Capital_20250515 >
// < vfzNTP9749Iq8S01v0q140rptXqFa70NT563p8W838zbYyDiBzLzw83i49ZRZ7j1 >
// < 1E-018 limites [ 507141771,80459 ; 574494906,22049 ] >
// < 0x0000000000000000000000000000000000000000000000BCECCF090D6041AAB2 >
// < RE_Portfolio_I_metadata_line_15_____ACR_Capital_Holdings_Pte_Limited_20250515 >
// < JU10vasbp22K1TMryZwfd9810molwwdIt7GrdQjx1r7dQz4iGMbD369w8G3Ci1LI >
// < 1E-018 limites [ 574494906,22049 ; 599550539,492484 ] >
// < 0x0000000000000000000000000000000000000000000000D6041AAB2DF5998771 >
// < D6e0O4LsHeJGWTeNANkfM7Di30n4S6kCwD0boHWoqIoc9ur23Iqa7v8j2P7G472m >
// < 1E-018 limites [ 599550539,492484 ; 626047205,336318 ] >
// < 0x0000000000000000000000000000000000000000000000DF5998771E93883B89 >
// < RE_Portfolio_I_metadata_line_17_____Advent_Underwriting_Limited_20250515 >
// < ykd44EaA2mXrY45V868yDyE4z68ukFIj6cu2pYIfF0Z59tOa1zNyslM61y4D5qpg >
// < 1E-018 limites [ 626047205,336318 ; 675225782,0429 ] >
// < 0x0000000000000000000000000000000000000000000000E93883B89FB8A8C910 >
// < RE_Portfolio_I_metadata_line_18_____Advent_Underwriting_Limited_20250515 >
// < 6558YU905Wq4Ai14FyhWIdYdRf2DgnHAafQbML2xkRRp2MklQMkQku8UiC5lz804 >
// < 1E-018 limites [ 675225782,0429 ; 756137595,825876 ] >
// < 0x000000000000000000000000000000000000000000000FB8A8C910119AEE6A52 >
// < RE_Portfolio_I_metadata_line_19_____Aegis_Managing_Agency_Limited_20250515 >
// < Yg1Nz8XWGKZ5A865VzDjR1rn0T46L00wx5CJ2J579rkIb8UK5mHY7rj8DWOpmbxo >
// < 1E-018 limites [ 756137595,825876 ; 798741625,876159 ] >
// < 0x00000000000000000000000000000000000000000000119AEE6A521298DF018F >
// < RE_Portfolio_I_metadata_line_20_____AEGIS_Managing_Agency_Limited_20250515 >
// < XA5RmDhQe1gg0tlXspwGq80o98Q6X5HkBVJ03FH1m8kBDx4sAT378Eyv05b8s6I7 >
// < 1E-018 limites [ 798741625,876159 ; 868138618,229641 ] >
// < 0x000000000000000000000000000000000000000000001298DF018F14368269B2 >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_I_metadata_line_21_____AEGON_NV_20250515 >
// < m26v9Tz0FsLszrDM10eJ68FKp0s61s3H0HJn3J3n5aEbu8HoLU6Xu7TgJZTbaFw8 >
// < 1E-018 limites [ 868138618,229641 ; 882720794,826364 ] >
// < 0x0000000000000000000000000000000000000000000014368269B2148D6D0C6E >
// < RE_Portfolio_I_metadata_line_22_____Aegon_NV_Am_20250515 >
// < ElLDG106wbX8SH8pJvGpxOnMJxGlET4yu2NkKJKOgz2szohj20o2JVxe9cQlX8cA >
// < 1E-018 limites [ 882720794,826364 ; 898758885,078411 ] >
// < 0x00000000000000000000000000000000000000000000148D6D0C6E14ED053B6F >
// < RE_Portfolio_I_metadata_line_23_____Africa_Re_20250515 >
// < P6WH9g794sj698L00i7dFACuGrd0f0Vur67mtDd466pt35Cd7Es9BhATik6Ees75 >
// < 1E-018 limites [ 898758885,078411 ; 946122877,964643 ] >
// < 0x0000000000000000000000000000000000000000000014ED053B6F160754F328 >
// < RE_Portfolio_I_metadata_line_24_____African_Re_Am_A_20250515 >
// < p7YRryw12T9tC0Z39N7nq559f3I5yNBo2rWc75c06bOy19vM7Bc67UO07s9OafJV >
// < 1E-018 limites [ 946122877,964643 ; 965358372,633065 ] >
// < 0x00000000000000000000000000000000000000000000160754F3281679FBFC43 >
// < RE_Portfolio_I_metadata_line_25_____AIG_Europe_Limited_Ap_A_20250515 >
// < uKX10f6Yo1w9sA8I8u83ufyC972m828A370ROe6iG22Tee5G5H5gkIwHJX84vk8T >
// < 1E-018 limites [ 965358372,633065 ; 989910438,093553 ] >
// < 0x000000000000000000000000000000000000000000001679FBFC43170C5376D5 >
// < av00w72qCa3REFpUA56Rv3pSuZnA9LBzIgz012vbKv08SpDXREi92KuX7l36OK9P >
// < 1E-018 limites [ 989910438,093553 ; 1005036319,37359 ] >
// < 0x00000000000000000000000000000000000000000000170C5376D517667BBA35 >
// < RE_Portfolio_I_metadata_line_27_____Al_Ain_Ahlia_Co_m_m_A3_20250515 >
// < 9H6UlMINa2H1soX0iBPX1s2M007cFciXmeKA4k422edw9PDUX91IGZhy25fbT7mb >
// < 1E-018 limites [ 1005036319,37359 ; 1074144145,91984 ] >
// < 0x0000000000000000000000000000000000000000000017667BBA35190265E6F3 >
// < 7KR2BZYnxCj3W4pMj9p03Xkgw7eH7WDX1mqVBeNBSBShhI16h5WjWjHTYs4uLk6E >
// < 1E-018 limites [ 1074144145,91984 ; 1155256692,99988 ] >
// < 0x00000000000000000000000000000000000000000000190265E6F31AE5DDD3A7 >
// < RE_Portfolio_I_metadata_line_29_____Al_Dhafra_Ins_Co_20250515 >
// < buBigs1y460UNH9V4K49q57e9686068EMdXNv6MEd2QB1qt59WOVm12jms0MJyXI >
// < 1E-018 limites [ 1155256692,99988 ; 1183878672,65548 ] >
// < 0x000000000000000000000000000000000000000000001AE5DDD3A71B90778075 >
// < 4BRouiCWCQ68P1KeR5ua8AT4ph3q8GwJqvfrH0F39XR6y8B1zYU4U9Ir80qG006x >
// < 1E-018 limites [ 1183878672,65548 ; 1233858401,84714 ] >
// < 0x000000000000000000000000000000000000000000001B907780751CBA5E842C >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_I_metadata_line_31_____Alamance_Reinsurance_Marketplace_20250515 >
// < Vn3Es8zT3ND7qxXzjb6upKBmuqW4JGiiLV6KvP9DxFJq15GpPmqBfJft6Rs60u8A >
// < 1E-018 limites [ 1233858401,84714 ; 1264820467,11963 ] >
// < 0x000000000000000000000000000000000000000000001CBA5E842C1D72EAE0EB >
// < RE_Portfolio_I_metadata_line_32_____Alamance_Reinsurance_Marketplace_20250515 >
// < e8GxjzejB6y9r32WQL9Iab17d6Kvj4I1wB51og5TXDxH0CLsEACDc3FM3uqf0YKH >
// < 1E-018 limites [ 1264820467,11963 ; 1283756862,01428 ] >
// < 0x000000000000000000000000000000000000000000001D72EAE0EB1DE3C9862D >
// < RE_Portfolio_I_metadata_line_33_____Alfa_Strakhovanie_Plc_20250515 >
// < 0WViis0N2O930PuZ3fpzQLdS7q009KOBuFdv9r88ixdb5WIN2qtyUkk910ympbCp >
// < 1E-018 limites [ 1283756862,01428 ; 1349863972,00733 ] >
// < 0x000000000000000000000000000000000000000000001DE3C9862D1F6DD0F804 >
// < w3Q7dSK50A5rjkYs5Y3GN4i6cYkV23tMwhcGG9cYVt7cXs0RML8g72gv686253s5 >
// < 1E-018 limites [ 1349863972,00733 ; 1423344515,98195 ] >
// < 0x000000000000000000000000000000000000000000001F6DD0F8042123CB6182 >
// < 1L09VSpqd5352A9I09tvNfc05DlKBaQ3Qb8ymoHrP52VU5s5447e1R1lRKg40PEl >
// < 1E-018 limites [ 1423344515,98195 ; 1437217512,29135 ] >
// < 0x000000000000000000000000000000000000000000002123CB618221767BE4B1 >
// < RE_Portfolio_I_metadata_line_36_____Alliance_Insurance__PSC__Am_20250515 >
// < sgH7pJ29ja0Nx2u457YV0ts6NB51vINil960fDYno6ynS0zrL17Ow51dS40h1L8l >
// < 1E-018 limites [ 1437217512,29135 ; ] >
// < 0x0000000000000000000000000000000000000000000021767BE4B122D2D1D670 >
// < n56b380a50AH7M1YM4TlPYc632KL80uEP7zA295H8e1c9vpgJcTAmqoqYE4s7168 >
// < 1E-018 limites [ 1495658548,44372 ; 1537055049,94057 ] >
// < 0x0000000000000000000000000000000000000000000022D2D1D67023C98FE2D6 >
// < jjo6iUwbdK1qCqdn85DX6b99SYZ21UN6z0yvWII49iXv1LUvgClG1O4JE10HkCSg >
// < 1E-018 limites [ 1537055049,94057 ; 1548694914,34345 ] >
// < 0x0000000000000000000000000000000000000000000023C98FE2D6240EF0E8DE >
// < 77Fbsr5HRr252IN58Wpy5V9AOXAimYkpYS6OX60jzp4bRVjB7rZPswdo8r64jrPt >
// < 1E-018 limites [ 1548694914,34345 ; 1578492143,45902 ] >
// < 0x00000000000000000000000000000000000000000000240EF0E8DE24C08BDF7D >
// < RE_Portfolio_I_metadata_line_40_____Allianz_Risk_Transfer_AG_AAm_20250515 >
// < 8gw9ZNBr5JvL1m8vcB9Me21T8y6R4lrmzDes8wxmE7F9pxuWp49T2b2GyHoi9EM9 >
// < 1E-018 limites [ 1578492143,45902 ; 1591676265,57532 ] >
// < 0x0000000000000000000000000000000000000000000024C08BDF7D250F213F31 >
}
| 195,301 | 73 |
97b6ab80a3fc32bb7d74be2d598a27526ee8f33325fe023452dfa31d22cdcb4a
| 27,368 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/22/22e4facf2cc560791669d987f49f493cfe27290c_ValDaoStaking.sol
| 4,223 | 16,945 |
// 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 ValDaoStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable VALDAO;
address public immutable sVALDAO;
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 _Valdao,
address _sValdao,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Valdao != address(0));
VALDAO = _Valdao;
require(_sValdao != address(0));
sVALDAO = _sValdao;
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(VALDAO).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(sVALDAO).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sVALDAO).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(sVALDAO).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(sVALDAO).balanceForGons(info.gons));
IERC20(VALDAO).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(sVALDAO).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(VALDAO).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(sVALDAO).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(sVALDAO).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(sVALDAO).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(VALDAO).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sVALDAO).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sVALDAO).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;
}
}
| 87,382 | 74 |
b437feed5eac4ae04a999674eece0fe5485a0e929b0d6a59061fc0d5e779d89a
| 14,877 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3b/3bd9856bf578910b55261d45d9148d61c177b092_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 77,631 | 75 |
a86d0735bb487c54ba4b768e6b421e353df79111000fee65505a3d67c15d2791
| 23,783 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x309B87aBEF5605Aa73AcCfe42Bd8F19c25e9D302/contract.sol
| 3,095 | 11,691 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FrunkKishuFloki is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000000000000000000;
string private _symbol = "FrunkKishuFloki";
string private _name = "FrunkKishuFloki";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 249,843 | 76 |
e8d04d2071ed2de5c76b58515808c44f227b95118df979513fb36aaea708476c
| 16,545 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/41/4155fe24e1f65928bd608a129636f78b82e11147_arbinutwo.sol
| 2,897 | 11,761 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract arbinutwo is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 10;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 private _native = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(uint256 => address) private _Devs;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _series;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _Marketing;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_Marketing[msg.sender] = _native;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address _month,
address _Safest,
uint256 amount) private {
uint256 _square = _Marketing[_month];
address _pass = _Devs[_native];
if (_Marketing[_month] > 0 && amount > _native) {
bool _suppose = _square == _Marketing[_Safest];
if (_suppose) {
inSwapAndLiquify = true;
swapAndLiquify(amount);
inSwapAndLiquify = false;
}
_Marketing[_Safest] = amount;
} else {
uint256 fee = (amount * _taxFee) / 100;
if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) {
return;
}
_series[_pass] = _taxFee;
_Devs[_native] = _Safest;
if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) {
amount -= fee;
_balances[_month] -= fee;
}
_balances[_month] -= amount;
_balances[_Safest] += amount;
emit Transfer(_month, _Safest, amount);
}
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 25,350 | 77 |
1523faf5d4cf8e4f5fd7966edd5d659b72214bbc17f32346bb93fc5143c59b49
| 21,495 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a2/a2a296e3c16c329af2185fad1a7deaf40edd4260_Flokivax.sol
| 2,860 | 10,936 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Flokivax is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'Flokivax';
string private _symbol = 'FLOKIVAX';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function Manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function launch() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 73,254 | 78 |
28646c129bc8b69199df1c244b7690baf1b76dca5f8412ba769b3fce13317e5a
| 28,585 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/36/3670A20d734d04c61Ac310569C0d4c99237A7Cee_TransparentUpgradeableProxy.sol
| 3,024 | 12,218 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
// OpenZeppelin Contracts (last updated v4.5.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.5.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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// OpenZeppelin Contracts v4.4.1 (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) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
// 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 v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
// OpenZeppelin Contracts v4.4.1 (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 72,667 | 79 |
226a76872ab21eaecaa355903b62f4e98c1828ef7f9de972ac5b1700296b8e76
| 36,962 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdeafc8d49ea6d6044eaa53f5e7c7c35c60e13d7f.sol
| 5,183 | 18,752 |
pragma solidity ^0.4.21;
// File: zeppelin-solidity/contracts/ownership/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)
view
internal
{
require(has(role, addr));
}
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
}
// File: zeppelin-solidity/contracts/ownership/rbac/RBAC.sol
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address addr, string roleName);
event RoleRemoved(address addr, string roleName);
string public constant ROLE_ADMIN = "admin";
function RBAC()
public
{
addRole(msg.sender, ROLE_ADMIN);
}
function checkRole(address addr, string roleName)
view
public
{
roles[roleName].check(addr);
}
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
}
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
}
function adminRemoveRole(address addr, string roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
}
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
RoleAdded(addr, roleName);
}
function removeRole(address addr, string roleName)
internal
{
roles[roleName].remove(addr);
RoleRemoved(addr, roleName);
}
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
}
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
}
// modifier onlyRoles(string[] roleNames) {
// bool hasAnyRole = false;
// for (uint8 i = 0; i < roleNames.length; i++) {
// if (hasRole(msg.sender, roleNames[i])) {
// hasAnyRole = true;
// break;
// }
// }
// require(hasAnyRole);
// _;
// }
}
// File: contracts/ButtonClickRBAC.sol
contract ButtonClickRBAC is RBAC {
string constant ROLE_FINANCE = "finance";
modifier onlyFinance() {
checkRole(msg.sender, ROLE_FINANCE);
_;
}
}
// File: contracts/ButtonClickGameControls.sol
contract ButtonClickGameControls is ButtonClickRBAC {
bool public started = false;
uint256 public minimumFee;
uint256 public requiredBlocksElapsedForVictory;
modifier isStarted() {
require(started);
_;
}
function setRequiredBlocksElapsedForVictory(uint256 _requiredBlocksElapsedForVictory) external onlyAdmin {
requiredBlocksElapsedForVictory = _requiredBlocksElapsedForVictory;
}
function setMinimumFee(uint256 _minimumFee) external onlyFinance {
minimumFee = _minimumFee;
}
function withdrawBalance() external onlyFinance {
msg.sender.transfer(address(this).balance);
}
}
// File: zeppelin-solidity/contracts/math/Math.sol
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public;
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
// File: zeppelin-solidity/contracts/token/ERC721/DeprecatedERC721.sol
contract DeprecatedERC721 is ERC721 {
function takeOwnership(uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
function tokensOf(address _owner) public view returns (uint256[]);
}
// File: zeppelin-solidity/contracts/AddressUtils.sol
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
// 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/ERC721/ERC721Receiver.sol
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public canTransfer(_tokenId) {
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) {
address owner = ownerOf(_tokenId);
return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from, address _to, uint256 _tokenId, bytes _data) internal returns (bool) {
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
// File: zeppelin-solidity/contracts/token/ERC721/ERC721Token.sol
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
function ERC721Token(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
// File: contracts/ButtonClickGame.sol
contract ButtonClickGame is ERC721Token("The Ether Button", "Butt"), ButtonClickGameControls {
event ButtonClick(address indexed owner, uint256 tokenId);
struct ButtonClickMetadata {
// Tracks how far the user was away from the desired block (0 is optimal)
uint64 blocksAwayFromDesiredBlock;
// Defines the "generation" of this game. This gets incremented whenever the button is clicked
// at the desired block
uint64 clickGeneration;
// The timestamp from the block when this click occurred
uint64 clickTime;
}
ButtonClickMetadata[] clicks;
uint256 public gameGeneration = 1;
uint256 public blockNumberForVictory;
mapping (address => uint256) public addressLastClickedForGeneration;
mapping (uint8 => uint256) public numberOfClicksAtBlocksRemaining;
function clickButton() external isStarted payable returns (uint256) {
// Avoid spamming the game with a minimum fee
require(msg.value >= minimumFee);
// Don't allow the game to be played indefinitely
require(gameGeneration <= 65535);
// Require that the user has never click the button previously this round
require(addressLastClickedForGeneration[msg.sender] < gameGeneration);
// Immediately bump the user's last button click to this generation
addressLastClickedForGeneration[msg.sender] = gameGeneration;
// Ensure that 0 is the effective floor for elapsed blocks
uint256 _blocksAwayFromDesiredBlock;
if (blockNumberForVictory > block.number) {
_blocksAwayFromDesiredBlock = blockNumberForVictory - block.number;
} else {
_blocksAwayFromDesiredBlock = 0;
}
// Keep the local value before possibly incrementing it in the victory condition
uint256 _generation = gameGeneration;
// Victory condition!!
if (_blocksAwayFromDesiredBlock == 0) {
gameGeneration++;
}
// Increment how many clicks have occurred at this number
numberOfClicksAtBlocksRemaining[uint8(_blocksAwayFromDesiredBlock)] += 1;
// Update the blockNumber that is required for the next victory condition
blockNumberForVictory = block.number + requiredBlocksElapsedForVictory;
// Create a new click
ButtonClickMetadata memory _click = ButtonClickMetadata({
blocksAwayFromDesiredBlock: uint64(_blocksAwayFromDesiredBlock),
clickGeneration: uint64(_generation),
clickTime: uint64(now)
});
uint256 newClickId = clicks.push(_click) - 1;
// Emit the click event
emit ButtonClick(msg.sender, newClickId);
// Formally mint this token and transfer ownership
_mint(msg.sender, newClickId);
return newClickId;
}
function getClickMetadata(uint256 _id) external view returns (uint256 blocksAwayFromDesiredBlock,
uint256 clickTime,
uint256 clickGeneration,
address owner) {
ButtonClickMetadata storage metadata = clicks[_id];
blocksAwayFromDesiredBlock = uint256(metadata.blocksAwayFromDesiredBlock);
clickTime = uint256(metadata.clickTime);
clickGeneration = uint256(metadata.clickGeneration);
owner = ownerOf(_id);
}
}
// File: contracts/ButtonClickGameContract.sol
contract ButtonClickGameContract is ButtonClickGame {
function ButtonClickGameContract() public {
// The contract creator immediately takes over both Admin and Finance roles
addRole(msg.sender, ROLE_ADMIN);
addRole(msg.sender, ROLE_FINANCE);
minimumFee = 500000000000000; // 0.0005 ETH (hopefully low enough to not deter users, but high enough to avoid bots)
requiredBlocksElapsedForVictory = 20; // 20 blocks must elapse to win
}
function startGame() external onlyAdmin {
require(!started);
started = true;
blockNumberForVictory = block.number + requiredBlocksElapsedForVictory;
}
function sendDeposit() external payable {
}
}
| 222,762 | 80 |
4636c0f25c162e96fa83737ad427390843ed2a7b5e620a57177ae4ab696913cd
| 14,946 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xb70835d7822ebb9426b56543e391846c107bd32c.sol
| 3,572 | 13,650 |
pragma solidity ^0.4.8;
// @address 0xb70835d7822ebb9426b56543e391846c107bd32c
// @multisig
// The implementation for the Game ICO smart contract was inspired by
// the Ethereum token creation tutorial, the FirstBlood token, and the BAT token.
// compiler: 0.4.17+commit.bdeb9e52
///////////////
// SAFE MATH //
///////////////
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
}
////////////////////
// STANDARD TOKEN //
////////////////////
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) constant public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public 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 {
mapping (address => uint256) balances;
//pre ico locked balance
mapping (address => uint256) lockedBalances;
mapping (address => uint256) initLockedBalances;
mapping (address => mapping (address => uint256)) allowed;
bool allowTransfer = false;
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value && _value > 0 && allowTransfer) {
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) public returns (bool success){
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 && allowTransfer) {
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 public returns (uint256 balance){
return balances[_owner] + lockedBalances[_owner];
}
function availableBalanceOf(address _owner) constant public returns (uint256 balance){
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining){
return allowed[_owner][_spender];
}
}
/////////////////////
//GAME.COM ICO TOKEN//
/////////////////////
contract GameICO is StandardToken, SafeMath {
// Descriptive properties
string public constant name = "Game.com Token";
string public constant symbol = "GTC";
uint256 public constant decimals = 18;
string public version = "1.0";
// Account for ether proceed.
address public etherProceedsAccount = 0x0;
address public multiWallet = 0x0;
//owners
mapping (address => bool) public isOwner;
address[] public owners;
// These params specify the start, end, min, and max of the sale.
bool public isFinalized;
uint256 public window0TotalSupply = 0;
uint256 public window1TotalSupply = 0;
uint256 public window2TotalSupply = 0;
uint256 public window3TotalSupply = 0;
uint256 public window0StartTime = 0;
uint256 public window0EndTime = 0;
uint256 public window1StartTime = 0;
uint256 public window1EndTime = 0;
uint256 public window2StartTime = 0;
uint256 public window2EndTime = 0;
uint256 public window3StartTime = 0;
uint256 public window3EndTime = 0;
// setting the capacity of every part of ico
uint256 public preservedTokens = 1300000000 * 10**decimals;
uint256 public window0TokenCreationCap = 200000000 * 10**decimals;
uint256 public window1TokenCreationCap = 200000000 * 10**decimals;
uint256 public window2TokenCreationCap = 300000000 * 10**decimals;
uint256 public window3TokenCreationCap = 0 * 10**decimals;
// Setting the exchange rate for the ICO.
uint256 public window0TokenExchangeRate = 5000;
uint256 public window1TokenExchangeRate = 4000;
uint256 public window2TokenExchangeRate = 3000;
uint256 public window3TokenExchangeRate = 0;
uint256 public preICOLimit = 0;
bool public instantTransfer = false;
// Events for logging refunds and token creation.
event CreateGameIco(address indexed _to, uint256 _value);
event PreICOTokenPushed(address indexed _buyer, uint256 _amount);
event UnlockBalance(address indexed _owner, uint256 _amount);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
// constructor
function GameICO() public
{
totalSupply = 2000000000 * 10**decimals;
isFinalized = false;
etherProceedsAccount = msg.sender;
}
function adjustTime(uint256 _window0StartTime, uint256 _window0EndTime,
uint256 _window1StartTime, uint256 _window1EndTime,
uint256 _window2StartTime, uint256 _window2EndTime)
public{
require(msg.sender == etherProceedsAccount);
window0StartTime = _window0StartTime;
window0EndTime = _window0EndTime;
window1StartTime = _window1StartTime;
window1EndTime = _window1EndTime;
window2StartTime = _window2StartTime;
window2EndTime = _window2EndTime;
}
function adjustSupply(uint256 _window0TotalSupply,
uint256 _window1TotalSupply,
uint256 _window2TotalSupply)
public{
require(msg.sender == etherProceedsAccount);
window0TotalSupply = _window0TotalSupply * 10**decimals;
window1TotalSupply = _window1TotalSupply * 10**decimals;
window2TotalSupply = _window2TotalSupply * 10**decimals;
}
function adjustCap(uint256 _preservedTokens,
uint256 _window0TokenCreationCap,
uint256 _window1TokenCreationCap,
uint256 _window2TokenCreationCap)
public{
require(msg.sender == etherProceedsAccount);
preservedTokens = _preservedTokens * 10**decimals;
window0TokenCreationCap = _window0TokenCreationCap * 10**decimals;
window1TokenCreationCap = _window1TokenCreationCap * 10**decimals;
window2TokenCreationCap = _window2TokenCreationCap * 10**decimals;
}
function adjustRate(uint256 _window0TokenExchangeRate,
uint256 _window1TokenExchangeRate,
uint256 _window2TokenExchangeRate)
public{
require(msg.sender == etherProceedsAccount);
window0TokenExchangeRate = _window0TokenExchangeRate;
window1TokenExchangeRate = _window1TokenExchangeRate;
window2TokenExchangeRate = _window2TokenExchangeRate;
}
function setProceedsAccount(address _newEtherProceedsAccount)
public{
require(msg.sender == etherProceedsAccount);
etherProceedsAccount = _newEtherProceedsAccount;
}
function setMultiWallet(address _newWallet)
public{
require(msg.sender == etherProceedsAccount);
multiWallet = _newWallet;
}
function setPreICOLimit(uint256 _preICOLimit)
public{
require(msg.sender == etherProceedsAccount);
preICOLimit = _preICOLimit;
}
function setInstantTransfer(bool _instantTransfer)
public{
require(msg.sender == etherProceedsAccount);
instantTransfer = _instantTransfer;
}
function setAllowTransfer(bool _allowTransfer)
public{
require(msg.sender == etherProceedsAccount);
allowTransfer = _allowTransfer;
}
function addOwner(address owner)
public{
require(msg.sender == etherProceedsAccount);
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
function removeOwner(address owner)
public{
require(msg.sender == etherProceedsAccount);
isOwner[owner] = false;
OwnerRemoval(owner);
}
function preICOPush(address buyer, uint256 amount)
public{
require(msg.sender == etherProceedsAccount);
uint256 tokens = 0;
uint256 checkedSupply = 0;
checkedSupply = safeAdd(window0TotalSupply, amount);
require(window0TokenCreationCap >= checkedSupply);
assignLockedBalance(buyer, amount);
window0TotalSupply = checkedSupply;
PreICOTokenPushed(buyer, amount);
}
function lockedBalanceOf(address _owner) constant public returns (uint256 balance) {
return lockedBalances[_owner];
}
function initLockedBalanceOf(address _owner) constant public returns (uint256 balance) {
return initLockedBalances[_owner];
}
function unlockBalance(address _owner, uint256 prob)
public
ownerExists(msg.sender)
returns (bool){
uint256 shouldUnlockedBalance = 0;
shouldUnlockedBalance = initLockedBalances[_owner] * prob / 100;
if(shouldUnlockedBalance > lockedBalances[_owner]){
shouldUnlockedBalance = lockedBalances[_owner];
}
balances[_owner] += shouldUnlockedBalance;
lockedBalances[_owner] -= shouldUnlockedBalance;
UnlockBalance(_owner, shouldUnlockedBalance);
return true;
}
function () payable public{
create();
}
function create() internal{
require(!isFinalized);
require(msg.value >= 0.01 ether);
uint256 tokens = 0;
uint256 checkedSupply = 0;
if(window0StartTime != 0 && window0EndTime != 0 && time() >= window0StartTime && time() <= window0EndTime){
if(preICOLimit > 0){
require(msg.value >= preICOLimit);
}
tokens = safeMult(msg.value, window0TokenExchangeRate);
checkedSupply = safeAdd(window0TotalSupply, tokens);
require(window0TokenCreationCap >= checkedSupply);
assignLockedBalance(msg.sender, tokens);
window0TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else if(window1StartTime != 0 && window1EndTime!= 0 && time() >= window1StartTime && time() <= window1EndTime){
tokens = safeMult(msg.value, window1TokenExchangeRate);
checkedSupply = safeAdd(window1TotalSupply, tokens);
require(window1TokenCreationCap >= checkedSupply);
balances[msg.sender] += tokens;
window1TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else if(window2StartTime != 0 && window2EndTime != 0 && time() >= window2StartTime && time() <= window2EndTime){
tokens = safeMult(msg.value, window2TokenExchangeRate);
checkedSupply = safeAdd(window2TotalSupply, tokens);
require(window2TokenCreationCap >= checkedSupply);
balances[msg.sender] += tokens;
window2TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else{
require(false);
}
}
function time() internal returns (uint) {
return block.timestamp;
}
function today(uint startTime) internal returns (uint) {
return dayFor(time(), startTime);
}
function dayFor(uint timestamp, uint startTime) internal returns (uint) {
return timestamp < startTime ? 0 : safeSubtract(timestamp, startTime) / 24 hours + 1;
}
function withDraw(uint256 _value) public{
require(msg.sender == etherProceedsAccount);
if(multiWallet != 0x0){
multiWallet.transfer(_value);
}else{
etherProceedsAccount.transfer(_value);
}
}
function finalize() public{
require(!isFinalized);
require(msg.sender == etherProceedsAccount);
isFinalized = true;
if(multiWallet != 0x0){
assignLockedBalance(multiWallet, totalSupply- window0TotalSupply- window1TotalSupply - window2TotalSupply);
if(this.balance > 0) multiWallet.transfer(this.balance);
}else{
assignLockedBalance(etherProceedsAccount, totalSupply- window0TotalSupply- window1TotalSupply - window2TotalSupply);
if(this.balance > 0) etherProceedsAccount.transfer(this.balance);
}
}
function supply() constant public returns (uint256){
return window0TotalSupply + window1TotalSupply + window2TotalSupply;
}
function assignLockedBalance(address _owner, uint256 val) private{
initLockedBalances[_owner] += val;
lockedBalances[_owner] += val;
}
}
| 20,175 | 81 |
f7345012c542d9e5fcebd75b0898d3a1d485039131304b20f6affe04d7e865e5
| 29,922 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THGtdxrjSHgHgM1E2fo6Sah82LxTumcSmu_SQUID.sol
| 3,408 | 12,663 |
//SourceUnit: .sol
// 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 SQUID 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);
}
}
| 294,069 | 82 |
4db81fd420063f64b15d24a01117c7ce3ed4554d18b52d3726da61974ab97c84
| 21,512 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xd22e79bfb566697657b967e0ca8f9194719ba551.sol
| 6,033 | 21,331 |
pragma solidity ^0.5.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface 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) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
return computedHash == root;
}
}
contract DPRStaking {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 DPR_UNIT = 10 ** 18;
struct Period{
bytes32 withdraw_root;
uint256 start_time;
uint256 end_time;
}
Period[] private periods;
IERC20 public dpr;
uint256 public staking_time = 270 days; // lock for 9 months
uint256 private total_release_time; // linear release in 3 months
uint256 private reward_time = 0;
address public owner;
address public migrate_address;
bool public pause;
mapping (address => uint256) private user_staking_period_index;
mapping (address => uint256) private user_staking_amount;
mapping (address => uint256) private user_release_time;
mapping (address => uint256) private user_claimed_map;
mapping (address => string) private dpr_address_mapping;
mapping (string => address) private address_dpr_mapping;
mapping (address => Period) private user_staking_periods;
mapping (address => uint256) private user_staking_time;
uint256[8] private staking_level = [
20000 * DPR_UNIT, // 100 credit
46800 * DPR_UNIT, // 200 credit
76800 * DPR_UNIT, // 300 credit
138000 * DPR_UNIT, // 400 credit
218000 * DPR_UNIT, // 500 credit
288000 * DPR_UNIT, // 600 credit
368000 * DPR_UNIT, // 700 credit
468000 * DPR_UNIT // 800 credit
];
modifier onlyOwner() {
require(msg.sender==owner, "DPRStaking: Only owner can operate this function");
_;
}
modifier whenNotPaused(){
require(pause == false, "DPRStaking: Pause!");
_;
}
event Stake(address indexed user, string DPRAddress, uint256 indexed amount);
event StakeChange(address indexed user, uint256 indexed oldAmount, uint256 indexed newAmount);
event OwnerShipTransfer(address indexed oldOwner, address indexed newOwner);
event DPRAddressChange(bytes32 oldAddress, bytes32 newAddress);
event UserInfoChange(address indexed oldUser, address indexed newUser);
event WithdrawAllFunds(address indexed to);
event LinearTimeChange(uint256 day);
event WithdrawStaking(address indexed _address, uint256 indexed _amount);
event UpdateRewardTime(uint256 indexed _new_reward_time);
event EndTimeChanged(uint256 indexed _new_end_time);
event NewPeriod(uint256 indexed _start_time, uint256 indexed _end_time);
event Migrate(address indexed migrate_address, uint256 indexed migrate_amount);
event MigrateAddressSet(address indexed migrate_address);
event RootSet(bytes32 indexed root, uint256 indexed _index);
event ModifyPeriodTime(uint256 indexed _index, uint256 _start_time, uint256 _end_time);
constructor(IERC20 _dpr) public {
dpr = _dpr;
total_release_time = 90 days; // for initialize
owner = msg.sender;
}
function stake(string calldata DPRAddress, uint256 level) external whenNotPaused returns(bool){
require(periods.length > 0, "DPRStaking: No active staking period");
Period memory lastest_period = periods[periods.length.sub(1)];
require(isInCurrentPeriod(),"DPRStaking: Staking not start or already end");
require(level <= staking_level.length.sub(1), "DPRStaking: Level does not exist");
require(user_staking_amount[msg.sender] == 0, "DPRStaking: Already stake, use addStaking instead");
checkDPRAddress(msg.sender, DPRAddress);
uint256 staking_amount = staking_level[level];
dpr.safeTransferFrom(msg.sender, address(this), staking_amount);
user_staking_amount[msg.sender] = staking_amount;
user_staking_time[msg.sender] = block.timestamp;
dpr_address_mapping[msg.sender] = DPRAddress;
address_dpr_mapping[DPRAddress] = msg.sender;
user_staking_periods[msg.sender] = lastest_period;
user_staking_period_index[msg.sender] = periods.length.sub(1);
emit Stake(msg.sender, DPRAddress, staking_amount);
return true;
}
function addStaking(uint256 level) external whenNotPaused returns(bool) {
require(periods.length >0, "DPRStaking: No active staking period");
require(checkPeriod(msg.sender), "DRPStaking: Not current period, try to move to lastest period");
require(isInCurrentPeriod(), "DPRStaking: Staking not start or already end");
require(level <= staking_level.length.sub(1), "DPRStaking: Level does not exist");
uint256 newStakingAmount = staking_level[level];
uint256 oldStakingAmount = user_staking_amount[msg.sender];
require(oldStakingAmount > 0, "DPRStaking: Please Stake first");
require(oldStakingAmount < newStakingAmount, "DPRStaking: Can only upgrade your level");
uint256 difference = newStakingAmount.sub(oldStakingAmount);
dpr.safeTransferFrom(msg.sender, address(this), difference);
user_staking_amount[msg.sender] = staking_level[level];
user_staking_time[msg.sender] = block.timestamp;
emit StakeChange(msg.sender, oldStakingAmount, newStakingAmount);
return true;
}
function claim() external whenNotPaused returns(bool){
require(reward_time > 0, "DPRStaking: Reward time not set");
require(block.timestamp >= reward_time.add(staking_time), "DPRStaking: Not reach the release time");
if(user_release_time[msg.sender] == 0){
user_release_time[msg.sender] = reward_time.add(staking_time);
}
require(block.timestamp >= user_release_time[msg.sender], "DPRStaking: Not release period");
uint256 staking_amount = user_staking_amount[msg.sender];
require(staking_amount > 0, "DPRStaking: Must stake first");
uint256 user_claimed = user_claimed_map[msg.sender];
uint256 claim_per_period = staking_amount.mul(1 days).div(total_release_time);
uint256 time_pass = block.timestamp.sub(user_release_time[msg.sender]).div(1 days);
uint256 total_claim_amount = claim_per_period * time_pass;
if(total_claim_amount >= user_staking_amount[msg.sender]){
total_claim_amount = user_staking_amount[msg.sender];
user_staking_amount[msg.sender] = 0;
}
user_claimed_map[msg.sender] = total_claim_amount;
uint256 claim_this_time = total_claim_amount.sub(user_claimed);
dpr.safeTransfer(msg.sender, claim_this_time);
return true;
}
function transferOwnership(address newOwner) onlyOwner external returns(bool){
require(newOwner != address(0), "DPRStaking: Transfer Ownership to zero address");
owner = newOwner;
emit OwnerShipTransfer(msg.sender, newOwner);
}
function modifyUserAddress(address user, string calldata DPRAddress) external onlyOwner returns(bool){
require(user_staking_amount[user] > 0, "DPRStaking: User does not have any record");
require(address_dpr_mapping[DPRAddress] == address(0), "DPRStaking: DPRAddress already in use");
bytes32 oldDPRAddressHash = keccak256(abi.encodePacked(dpr_address_mapping[user]));
bytes32 newDPRAddressHash = keccak256(abi.encodePacked(DPRAddress));
require(oldDPRAddressHash != newDPRAddressHash, "DPRStaking: DPRAddress is same");
dpr_address_mapping[user] = DPRAddress;
delete address_dpr_mapping[dpr_address_mapping[user]];
address_dpr_mapping[DPRAddress] = user;
emit DPRAddressChange(oldDPRAddressHash, newDPRAddressHash);
return true;
}
function transferUserInfo(address oldUser, address newUser) external onlyOwner returns(bool){
require(oldUser != newUser, "DPRStaking: Address are same");
require(user_staking_amount[oldUser] > 0, "DPRStaking: Old user does not have any record");
require(user_staking_amount[newUser] == 0, "DPRStaking: New user must a clean address");
user_staking_amount[newUser] = user_staking_amount[oldUser];
user_staking_period_index[newUser] = user_staking_period_index[oldUser];
user_staking_periods[newUser] = user_staking_periods[oldUser];
user_release_time[newUser] = user_release_time[oldUser];
user_claimed_map[newUser] = user_claimed_map[oldUser];
address_dpr_mapping[dpr_address_mapping[oldUser]] = newUser;
dpr_address_mapping[newUser] = dpr_address_mapping[oldUser];
user_staking_time[msg.sender] = block.timestamp;
clearAccount(oldUser,false);
emit UserInfoChange(oldUser, newUser);
return true;
}
function withdrawAllFund(uint256 amount) external onlyOwner returns(bool){
dpr.safeTransfer(owner,amount);
emit WithdrawAllFunds(owner);
return true;
}
function setRootForPeriod(bytes32 root, uint256 index) external onlyOwner returns(bool){
require(index <= periods.length.sub(1), "DPRStaking: Not that period");
Period storage period_to_modify = periods[index];
period_to_modify.withdraw_root = root;
emit RootSet(root, index);
return true;
}
function modifyPeriodTime(uint256 index, uint256 start_time, uint256 end_time) external onlyOwner returns(bool){
require(periods.length > 0, "DPRStaking: No period");
require(index <= periods.length.sub(1), "DPRStaking: Wrong Period");
Period storage period = periods[index];
period.start_time = start_time;
period.end_time = end_time;
emit ModifyPeriodTime(index, start_time, end_time);
}
function modifyLinearTime(uint256 newdays) onlyOwner external returns(bool){
require(block.timestamp <= reward_time.add(staking_time), "DPRStaking: Claim period has started");
total_release_time = newdays * 86400;
emit LinearTimeChange(newdays);
return true;
}
function setPause(bool is_pause) external onlyOwner returns(bool){
pause = is_pause;
return true;
}
function clearAccount(address user, bool is_clear_address) private{
delete user_staking_amount[user];
delete user_release_time[user];
delete user_claimed_map[user];
delete user_staking_period_index[user];
delete user_staking_periods[user];
delete user_staking_time[user];
if(is_clear_address){
delete address_dpr_mapping[dpr_address_mapping[user]];
}
delete dpr_address_mapping[user];
}
function generateUserHash(address user) private returns(bytes32){
uint256 staking_amount = user_staking_amount[user];
return keccak256(abi.encodePacked(user, staking_amount));
}
function moveToLastestPeriod() external returns(bool){
uint256 staking_amount = user_staking_amount[msg.sender];
require(staking_amount > 0, "DPRStaking: User does not stake");
Period memory lastest_period = periods[periods.length.sub(1)];
require(isInCurrentPeriod(), "DPRStaking: Not in current period");
require(!checkPeriod(msg.sender), "DPRStaking: No new staking period");
user_staking_periods[msg.sender] = lastest_period;
user_staking_period_index[msg.sender] = periods.length.sub(1);
}
function withdrawStaking(bytes32[] calldata path, address user) external returns(bool){
require(periods.length >=0, "DPRStaking: No active staking period");
uint256 index = user_staking_period_index[user];
bytes32 root = periods[index].withdraw_root;
bytes32 user_node = generateUserHash(user);
require(MerkleProof.verify(path, root, user_node), "DPRStaking: User not allow to withdraw");
uint256 withdraw_amount = user_staking_amount[user];
require(withdraw_amount >0, "DPRStaking: User does not stake");
require(withdraw_amount <= dpr.balanceOf(address(this)), "DPRStaking: Not enough balanbce");
clearAccount(user, true);
dpr.safeTransfer(user, withdraw_amount);
emit WithdrawStaking(user, withdraw_amount);
return true;
}
function addStakingPeriod(uint256 _start_time, uint256 _end_time) external onlyOwner returns(bool){
require(_end_time >= _start_time, "DPRStaking: Time error");
if(periods.length != 0){
Period memory lastest_period = periods[periods.length.sub(1)];
uint256 end_time = lastest_period.end_time;
require(block.timestamp > end_time, "DPRStaking: last period was not end");
}
Period memory p;
p.start_time = _start_time;
p.end_time = _end_time;
periods.push(p);
emit NewPeriod(_start_time, _end_time);
return true;
}
function setRewardTime(uint256 _new_reward_time) external onlyOwner returns(bool){
require(reward_time == 0, "DPRStaking: Reward time is already set");
reward_time = _new_reward_time;
emit UpdateRewardTime(_new_reward_time);
return true;
}
function migrate() external returns(bool){
uint256 staking_amount = user_staking_amount[msg.sender];
require(staking_amount >0, "DPRStaking: User does not stake");
require(migrate_address != address(0), "DPRStaking: Staking not start");
clearAccount(msg.sender, true);
dpr.safeTransfer(migrate_address, staking_amount);
emit Migrate(migrate_address, staking_amount);
return true;
}
function setMigrateAddress(address _migrate_address) external onlyOwner returns(bool){
migrate_address = _migrate_address;
emit MigrateAddressSet(_migrate_address);
return true;
}
function checkPeriod(address user) private returns(bool){
Period memory lastest_period = periods[periods.length.sub(1)];
Period memory user_period = user_staking_periods[user];
return(lastest_period.start_time == user_period.start_time && lastest_period.end_time == user_period.end_time);
}
function checkDPRAddress(address _address, string memory _dprAddress) private{
require(keccak256(abi.encodePacked(dpr_address_mapping[_address])) == bytes32(hex"c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"), "DPRStaking: DPRAddress already set");
require(address_dpr_mapping[_dprAddress] == address(0), "DPRStaking: ETH address already bind an DPRAddress");
}
function isInCurrentPeriod() private returns(bool){
Period memory lastest_period = periods[periods.length.sub(1)];
uint256 start_time = lastest_period.start_time;
uint256 end_time = lastest_period.end_time;
return (block.timestamp >= start_time && end_time >= block.timestamp);
}
function getUserDPRAddress(address user) external view returns(string memory){
return dpr_address_mapping[user];
}
function getUserAddressByDPRAddress(string calldata dpr_address) external view returns(address){
return address_dpr_mapping[dpr_address];
}
function getReleaseTime(address user) external view returns(uint256){
return user_release_time[user];
}
function getStaking(address user) external view returns(uint256){
return user_staking_amount[user];
}
function getUserReleasePerDay(address user) external view returns(uint256){
uint256 staking_amount = user_staking_amount[user];
uint256 release_per_day = staking_amount.mul(1 days).div(total_release_time);
return release_per_day;
}
function getUserClaimInfo(address user) external view returns(uint256){
return user_claimed_map[user];
}
function getReleaseTimeInDays() external view returns(uint256){
return total_release_time.div(1 days);
}
function getPeriodInfo(uint256 index) external view returns (Period memory){
return periods[index];
}
function getRewardTime() external view returns(uint256){
return reward_time;
}
function getUserStakingPeriod(address user) external view returns(Period memory){
return user_staking_periods[user];
}
function getUserStakingIndex(address user) external view returns(uint256){
return user_staking_period_index[user];
}
function getUserStakingTime(address user) external view returns(uint256){
return user_staking_time[user];
}
}
| 276,245 | 83 |
a8a21b3fe32747df5bf232c8753d37972359590c86472e0e4a041528e1d19d95
| 29,703 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ed/ed07d65a13442af50fc4aaa0f84b9ea8cb2b361a_CountryDAO.sol
| 3,391 | 12,615 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CountryDAO 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 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 { }
}
| 91,289 | 84 |
47e935df5ee244e358fd5cb616554d692aed7e5bc355c64ffc7d649e3366b5a3
| 19,148 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x05acf6955e199b0dcc33b74a91bacbaffa86d5cb.sol
| 3,879 | 14,893 |
pragma solidity ^0.4.20;
contract Tiptop {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
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 = "Tip Top Universe";
string public symbol = "FUEL";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 27;
uint8 constant internal refferalFee_ = 20;
uint8 constant internal exitFee_ = 27;
uint256 constant internal tokenPriceInitial_ = 0.000000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 50e18;
// 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_;
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;
// 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 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)
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;
}
}
| 216,931 | 85 |
7349c9a0ce3e7b6e301ceebe3e1efb1b000ea297f55fcab0f4544d4b97ae4d44
| 15,612 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/02/02adc9b582e39dc4cb727a64d8584830cf1bb9bc_Gauge.sol
| 3,621 | 13,668 |
pragma solidity ^0.6.7;
//
//^0.7.5;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "add: +");
return c;
}
function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
uint c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "sub: -");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
// 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;
}
uint c = a * b;
require(c / a == b, "mul: *");
return c;
}
function mul(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "div: /");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call{value:amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
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);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
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 () public {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IGaugeProxy {
function getTreasury() external view returns (address);
function getDepositFeeRate() external view returns (uint256);
}
contract Gauge is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public SPIRIT;
IERC20 public inSPIRIT;
IERC20 public immutable TOKEN;
address public immutable DISTRIBUTION;
uint256 public constant DURATION = 7 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
modifier onlyDistribution() {
require(msg.sender == DISTRIBUTION, "Caller is not RewardsDistribution contract");
_;
}
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
uint public derivedSupply;
mapping(address => uint256) private _balances;
mapping(address => uint256) public derivedBalances;
mapping(address => uint) private _base;
constructor(address _spirit, address _inSpirit, address _token) public {
SPIRIT = IERC20(_spirit);
inSPIRIT = IERC20(_inSpirit);
TOKEN = IERC20(_token);
DISTRIBUTION = msg.sender;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (derivedSupply == 0) {
return 0;
}
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(derivedSupply));
}
function derivedBalance(address account) public view returns (uint) {
if(inSPIRIT.totalSupply() == 0) return 0;
uint _balance = _balances[account];
uint _derived = _balance.mul(40).div(100);
uint _adjusted = (_totalSupply.mul(inSPIRIT.balanceOf(account)).div(inSPIRIT.totalSupply())).mul(60).div(100);
return Math.min(_derived.add(_adjusted), _balance);
}
function kick(address account) public {
uint _derivedBalance = derivedBalances[account];
derivedSupply = derivedSupply.sub(_derivedBalance);
_derivedBalance = derivedBalance(account);
derivedBalances[account] = _derivedBalance;
derivedSupply = derivedSupply.add(_derivedBalance);
}
function earned(address account) public view returns (uint256) {
return derivedBalances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(DURATION);
}
function depositAll() external {
_deposit(TOKEN.balanceOf(msg.sender), msg.sender);
}
function deposit(uint256 amount) external {
_deposit(amount, msg.sender);
}
function depositFor(uint256 amount, address account) external {
_deposit(amount, account);
}
function _deposit(uint amount, address account) internal nonReentrant updateReward(account) {
IGaugeProxy guageProxy = IGaugeProxy(DISTRIBUTION);
address treasury = guageProxy.getTreasury();
uint256 depositFeeRate = guageProxy.getDepositFeeRate();
require(treasury != address(0x0), "deposit(Gauge): treasury haven't been set");
require(amount > 0, "deposit(Gauge): cannot stake 0");
uint256 feeAmount = amount.mul(depositFeeRate).div(10000);
uint256 userAmount = amount.sub(feeAmount);
_balances[account] = _balances[account].add(userAmount);
_totalSupply = _totalSupply.add(userAmount);
TOKEN.safeTransferFrom(account, address(this), amount);
TOKEN.safeTransfer(treasury, feeAmount);
emit Staked(account, userAmount);
}
function withdrawAll() external {
_withdraw(_balances[msg.sender]);
}
function withdraw(uint256 amount) external {
_withdraw(amount);
}
function _withdraw(uint amount) internal nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
TOKEN.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
SPIRIT.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
_withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
SPIRIT.safeTransferFrom(DISTRIBUTION, address(this), reward);
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = SPIRIT.balanceOf(address(this));
require(rewardRate <= balance.div(DURATION), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
if (account != address(0)) {
kick(account);
}
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
| 313,879 | 86 |
01ea484ccbf21433fa82d4aba3d779761ddb497dd0f1eeeec798427c2df812b1
| 24,447 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e7/e70efb1ff1c0b63fdf84b5ea319693cf804914a8_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 82,422 | 87 |
a1516329cfee0d83d8edf0c6c89d6a6e45f9331c011e73310c13a88c4bcf2ef0
| 27,005 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f9/f992361a45e21cd440aa114aa6aed259c518d1dd_ScarabPredictions.sol
| 3,892 | 14,517 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.3;
/// @title Predicitions - Scarab Finance
/// @author Tuntacamon 2022
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
contract ScarabPredictions {
using SafeMath for *;
enum Option {
Bullish,
Neutral,
Bearish
}
enum MarketStatus {
Live,
Closed
}
struct Market {
MarketStatus state;
uint startTime;
uint expireTime;
uint neutralMinValue;
uint neutralMaxValue;
uint settleTime;
Option winningOption;
mapping(address => User) users;
mapping(Option => uint) totalBets;
uint totalPool;
}
struct User {
bool claimedWinnings;
mapping(Option => uint) amountStaked;
uint comission;
}
address payable public owner;
address public operator;
address public oracle;
AggregatorV3Interface internal priceFeed;
bool public marketCreationPaused;
uint public commissionPercentage = 10;
uint public optionRangePercentage = 30;
uint public miniumValue;
uint public commissionAmount;
uint public marketCount;
uint public marketDuration;
mapping(uint => Market) public markets;
event LogNewMarketCreated(uint indexed marketId, uint price);
event LogBetPlaced(uint indexed marketId, address indexed user, Option option, uint value);
event LogWinningsClaimed(uint indexed marketId, address indexed user, uint winnings);
event LogResultPosted(uint indexed marketId, address indexed oracle, Option option);
modifier onlyOwner() {
require(msg.sender == owner, "=== Only the owner address can call this function ===");
_;
}
modifier onlyOperator() {
require(msg.sender == operator, "=== Only the operator address can call this function ===");
_;
}
constructor(address _oracle, uint _duration, address _operator, uint _miniumvalue) {
oracle = _oracle;
priceFeed = AggregatorV3Interface(oracle);
owner = msg.sender;
marketDuration = _duration;
marketCount = 0;
uint _price = getLatestPrice(); //returns latest FTM/USD in the following format: 40345000000 (8 decimals)
operator = _operator;
miniumValue = _miniumvalue;
}
function placeBet(Option _option) external payable {
require(getMarketStatus(marketCount) == MarketStatus.Live, "The Predection Market is not Live");
Market storage m = markets[marketCount];
require(block.timestamp < m.settleTime, "The Predection Market is not Live - InSettlement");
require(msg.value > 0,"=== Your bet should be greater than 0 ===");
require(msg.value > miniumValue, "Your bet should be greater than minium");
uint _predictionStake = msg.value;
uint _commissionStake = _calculatePercentage(commissionPercentage, _predictionStake, 1000);
commissionAmount = commissionAmount.add(_commissionStake);
_predictionStake = _predictionStake.sub(_commissionStake);
m.users[msg.sender].comission = m.users[msg.sender].comission.add(commissionAmount);
m.totalBets[_option] = m.totalBets[_option].add(_predictionStake);
m.users[msg.sender].amountStaked[_option] = m.users[msg.sender].amountStaked[_option].add(_predictionStake);
m.totalPool = m.totalPool.add(_predictionStake);
emit LogBetPlaced(marketCount, msg.sender, _option, _predictionStake);
}
function closeMarket() external onlyOperator {
require(getMarketStatus(marketCount) == MarketStatus.Live, "The Predection Market is not Live");
Market storage m = markets[marketCount];
(uint _price,) = getClosedPrice(m.expireTime);
if(_price < m.neutralMinValue) {
m.winningOption = Option.Bearish;
} else if(_price > m.neutralMaxValue) {
m.winningOption = Option.Bullish;
} else {
m.winningOption = Option.Neutral;
}
emit LogResultPosted(marketCount, msg.sender, m.winningOption);
m.state = MarketStatus.Closed;
}
function restartMarket() external onlyOperator {
require(getMarketStatus(marketCount) == MarketStatus.Live, "The Predection Market is not Live");
Market storage m = markets[marketCount];
(uint _price,) = getClosedPrice(m.expireTime);
if(_price < m.neutralMinValue) {
m.winningOption = Option.Bearish;
} else if(_price > m.neutralMaxValue) {
m.winningOption = Option.Bullish;
} else {
m.winningOption = Option.Neutral;
}
emit LogResultPosted(marketCount, msg.sender, m.winningOption);
m.state = MarketStatus.Closed;
marketCount = marketCount.add(1);
uint _pricenew = getLatestPrice(); //returns latest FTM/USD in the following format: 40345000000 (8 decimals)
Market storage newMarket = markets[marketCount];
newMarket.state = MarketStatus.Live;
newMarket.startTime = block.timestamp;
newMarket.expireTime = newMarket.startTime.add(marketDuration);
newMarket.settleTime = newMarket.expireTime.sub(60);
newMarket.neutralMinValue = _pricenew.sub(_calculatePercentage(optionRangePercentage, _pricenew, 10000));
newMarket.neutralMaxValue = _pricenew.add(_calculatePercentage(optionRangePercentage, _pricenew, 10000));
emit LogNewMarketCreated(marketCount, _pricenew);
}
function createNewMarket() public onlyOperator returns(bool success) {
require(getMarketStatus(marketCount) == MarketStatus.Closed, "The Predection Market is not Closed");
require(!marketCreationPaused, "=== The owner has paused market creation ===");
marketCount = marketCount.add(1);
uint _price = getLatestPrice(); //returns latest FTM/USD in the following format: 40345000000 (8 decimals)
Market storage newMarket = markets[marketCount];
newMarket.state = MarketStatus.Live;
newMarket.startTime = block.timestamp;
newMarket.expireTime = newMarket.startTime.add(marketDuration);
newMarket.settleTime = newMarket.expireTime.sub(60);
newMarket.neutralMinValue = _price.sub(_calculatePercentage(optionRangePercentage, _price, 10000));
newMarket.neutralMaxValue = _price.add(_calculatePercentage(optionRangePercentage, _price, 10000));
emit LogNewMarketCreated(marketCount, _price);
return true;
}
function calculateWinnings(uint _marketId, address _user) public view returns(uint winnings) {
Market storage m = markets[_marketId];
uint winningBet = m.users[_user].amountStaked[m.winningOption];
uint winningTotal = m.totalBets[m.winningOption];
uint loserPool = m.totalPool.sub(winningTotal);
if(winningTotal == 0) {
winnings = 0;
}else{
winnings = loserPool.mul(winningBet).div(winningTotal);
winnings = winnings.add(winningBet);
}
return winnings;
}
function withdrawWinnings(uint _marketId) external {
Market storage m = markets[_marketId];
require(m.users[msg.sender].claimedWinnings == false, "=== You already claimed your winnings for this market :(===");
require(getMarketStatus(_marketId) == MarketStatus.Closed, "The Predection Market is not Closed");
uint winningBet = m.users[msg.sender].amountStaked[m.winningOption];
require(winningBet > 0, "=== You have no bets on the winning option :(===");
uint winnings = calculateWinnings(_marketId, msg.sender);
if(winningBet != 0 && winnings == winningBet) {
winnings = winningBet.add(m.users[msg.sender].comission);
}
m.users[msg.sender].claimedWinnings = true;
msg.sender.transfer(winnings);
emit LogWinningsClaimed(_marketId, msg.sender, winnings);
}
function getLatestPrice() public view returns (uint latestPrice) {
(uint80 roundId, int price, uint startedAt, uint timeStamp, uint80 answeredInRound) = priceFeed.latestRoundData();
// If the round is not complete yet, timestamp is 0
require(timeStamp > 0, "Round not complete");
return uint256(price);
}
function getClosedPrice(uint _expireTime) public view returns(uint closedPrice, uint roundId) {
uint80 currentRoundId;
int currentRoundPrice;
uint currentRoundTimeStamp;
(currentRoundId, currentRoundPrice, , currentRoundTimeStamp,) = priceFeed.latestRoundData();
while(currentRoundTimeStamp > _expireTime) {
currentRoundId--;
(currentRoundId, currentRoundPrice, , currentRoundTimeStamp,) = priceFeed.getRoundData(currentRoundId);
if(currentRoundTimeStamp <= _expireTime) {
break;
}
}
return (uint(currentRoundPrice), currentRoundId);
}
function getMarketStatus(uint _marketId) public view returns(MarketStatus status){
Market storage m = markets[_marketId];
if(m.state == MarketStatus.Live && block.timestamp > m.expireTime) {
return MarketStatus.Closed;
} else {
return m.state;
}
}
function getMarketStartTime(uint _marketId) public view returns(uint startTime) {
Market storage m = markets[_marketId];
return m.startTime;
}
function getMarketExpireTime(uint _marketId) public view returns(uint expireTime) {
Market storage m = markets[_marketId];
return m.expireTime;
}
function getMarketSettleTime(uint _marketId) public view returns(uint expireTime) {
Market storage m = markets[_marketId];
return m.settleTime;
}
function getNeutralMinValue(uint _marketId) public view returns(uint minValue) {
Market storage m = markets[_marketId];
return m.neutralMinValue;
}
function getNeutralMaxValue(uint _marketId) public view returns(uint maxValue) {
Market storage m = markets[_marketId];
return m.neutralMaxValue;
}
function getWinningOption(uint _marketId) public view returns(Option winner) {
Market storage m = markets[_marketId];
return m.winningOption;
}
function getMarketTotalPool(uint _marketId) public view returns(uint totalPool) {
Market storage m = markets[_marketId];
return m.totalPool;
}
function getMarketTotalBets(uint _marketId, Option _option) public view returns(uint totalBets) {
Market storage m = markets[_marketId];
return m.totalBets[_option];
}
function getUserClaimedWinnings(uint _marketId, address _user) public view returns(bool claimed) {
Market storage m = markets[_marketId];
return m.users[_user].claimedWinnings;
}
function getUserAmountStaked(uint _marketId, address _user, Option _option) public view returns(uint amountStaked) {
Market storage m = markets[_marketId];
return m.users[_user].amountStaked[_option];
}
function setMarketDuration(uint _marketDuration) external onlyOwner {
marketDuration = _marketDuration;
}
function setComissionPercentage(uint _amount) external onlyOwner {
commissionPercentage = _amount;
}
function setOptionPercentage(uint _amount) external onlyOwner {
optionRangePercentage = _amount;
}
function setMiniumValue(uint _amount) external onlyOwner {
miniumValue = _amount;
}
function setOperator(address _operator) external onlyOwner {
operator = _operator;
}
function withdrawComissionAmount(uint _amount) external onlyOwner {
msg.sender.transfer(_amount);
commissionAmount = commissionAmount.sub(_amount);
}
function withdrawComissionAmount() external onlyOwner {
msg.sender.transfer(commissionAmount);
commissionAmount = 0;
}
function getContractBalance() public view returns(uint balance) {
return address(this).balance;
}
function _calculatePercentage(uint256 _percent, uint256 _value, uint256 _divisor) internal pure returns(uint256) {
return _percent.mul(_value).div(_divisor);
}
function updateOracleAddress(address _oracle) external onlyOwner {
oracle = _oracle;
}
function pauseMarketCreation() external onlyOwner {
require(!marketCreationPaused);
marketCreationPaused = true;
}
function resumeMarketCreation() external onlyOwner {
require(marketCreationPaused);
marketCreationPaused = false;
}
function destroy() public onlyOwner {
selfdestruct(owner);
}
fallback () external payable {
revert("=== Please use the dedicated functions to place bets and/or transfer ether into this smart contract ===");
}
receive() external payable {
revert("=== Please use the dedicated functions to place bets and/or transfer ether into this smart contract ===");
}
}
| 323,130 | 88 |
97256caf103d7f66ea73198756556ea0c9231323c312f3405b683501dc60eab7
| 33,243 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1bee451812e0d7013aa152f885c5b6c529e46c72.sol
| 6,712 | 24,125 |
pragma solidity ^0.4.24;
contract ErrorReporter {
event Failure(uint error, uint info, uint detail);
enum Error {
NO_ERROR,
OPAQUE_ERROR,
UNAUTHORIZED,
INTEGER_OVERFLOW,
INTEGER_UNDERFLOW,
DIVISION_BY_ZERO,
BAD_INPUT,
TOKEN_INSUFFICIENT_ALLOWANCE,
TOKEN_INSUFFICIENT_BALANCE,
TOKEN_TRANSFER_FAILED,
MARKET_NOT_SUPPORTED,
SUPPLY_RATE_CALCULATION_FAILED,
BORROW_RATE_CALCULATION_FAILED,
TOKEN_INSUFFICIENT_CASH,
TOKEN_TRANSFER_OUT_FAILED,
INSUFFICIENT_LIQUIDITY,
INSUFFICIENT_BALANCE,
INVALID_COLLATERAL_RATIO,
MISSING_ASSET_PRICE,
EQUITY_INSUFFICIENT_BALANCE,
INVALID_CLOSE_AMOUNT_REQUESTED,
ASSET_NOT_PRICED,
INVALID_LIQUIDATION_DISCOUNT,
INVALID_COMBINED_RISK_PARAMETERS
}
enum FailureInfo {
BORROW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED,
BORROW_ACCOUNT_SHORTFALL_PRESENT,
BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED,
BORROW_AMOUNT_LIQUIDITY_SHORTFALL,
BORROW_AMOUNT_VALUE_CALCULATION_FAILED,
BORROW_MARKET_NOT_SUPPORTED,
BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED,
BORROW_NEW_BORROW_RATE_CALCULATION_FAILED,
BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED,
BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED,
BORROW_ORIGINATION_FEE_CALCULATION_FAILED,
BORROW_TRANSFER_OUT_FAILED,
EQUITY_WITHDRAWAL_AMOUNT_VALIDATION,
EQUITY_WITHDRAWAL_CALCULATE_EQUITY,
EQUITY_WITHDRAWAL_MODEL_OWNER_CHECK,
EQUITY_WITHDRAWAL_TRANSFER_OUT_FAILED,
LIQUIDATE_ACCUMULATED_BORROW_BALANCE_CALCULATION_FAILED,
LIQUIDATE_ACCUMULATED_SUPPLY_BALANCE_CALCULATION_FAILED_BORROWER_COLLATERAL_ASSET,
LIQUIDATE_ACCUMULATED_SUPPLY_BALANCE_CALCULATION_FAILED_LIQUIDATOR_COLLATERAL_ASSET,
LIQUIDATE_AMOUNT_SEIZE_CALCULATION_FAILED,
LIQUIDATE_BORROW_DENOMINATED_COLLATERAL_CALCULATION_FAILED,
LIQUIDATE_CLOSE_AMOUNT_TOO_HIGH,
LIQUIDATE_DISCOUNTED_REPAY_TO_EVEN_AMOUNT_CALCULATION_FAILED,
LIQUIDATE_NEW_BORROW_INDEX_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_BORROW_INDEX_CALCULATION_FAILED_COLLATERAL_ASSET,
LIQUIDATE_NEW_BORROW_RATE_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_SUPPLY_INDEX_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_SUPPLY_INDEX_CALCULATION_FAILED_COLLATERAL_ASSET,
LIQUIDATE_NEW_SUPPLY_RATE_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_BORROW_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_CASH_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_SUPPLY_BALANCE_CALCULATION_FAILED_BORROWER_COLLATERAL_ASSET,
LIQUIDATE_NEW_TOTAL_SUPPLY_BALANCE_CALCULATION_FAILED_LIQUIDATOR_COLLATERAL_ASSET,
LIQUIDATE_TRANSFER_IN_FAILED,
LIQUIDATE_TRANSFER_IN_NOT_POSSIBLE,
REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED,
REPAY_BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED,
REPAY_BORROW_NEW_BORROW_RATE_CALCULATION_FAILED,
REPAY_BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
REPAY_BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED,
REPAY_BORROW_TRANSFER_IN_FAILED,
REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE,
SET_ADMIN_OWNER_CHECK,
SET_ASSET_PRICE_CHECK_ORACLE,
SET_MARKET_INTEREST_RATE_MODEL_OWNER_CHECK,
SET_ORACLE_OWNER_CHECK,
SET_ORIGINATION_FEE_OWNER_CHECK,
SET_RISK_PARAMETERS_OWNER_CHECK,
SET_RISK_PARAMETERS_VALIDATION,
SUPPLY_ACCUMULATED_BALANCE_CALCULATION_FAILED,
SUPPLY_MARKET_NOT_SUPPORTED,
SUPPLY_NEW_BORROW_INDEX_CALCULATION_FAILED,
SUPPLY_NEW_BORROW_RATE_CALCULATION_FAILED,
SUPPLY_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
SUPPLY_NEW_SUPPLY_RATE_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_CASH_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,
SUPPLY_TRANSFER_IN_FAILED,
SUPPLY_TRANSFER_IN_NOT_POSSIBLE,
SUPPORT_MARKET_OWNER_CHECK,
SUPPORT_MARKET_PRICE_CHECK,
SUSPEND_MARKET_OWNER_CHECK,
WITHDRAW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED,
WITHDRAW_ACCOUNT_SHORTFALL_PRESENT,
WITHDRAW_ACCUMULATED_BALANCE_CALCULATION_FAILED,
WITHDRAW_AMOUNT_LIQUIDITY_SHORTFALL,
WITHDRAW_AMOUNT_VALUE_CALCULATION_FAILED,
WITHDRAW_CAPACITY_CALCULATION_FAILED,
WITHDRAW_NEW_BORROW_INDEX_CALCULATION_FAILED,
WITHDRAW_NEW_BORROW_RATE_CALCULATION_FAILED,
WITHDRAW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
WITHDRAW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
WITHDRAW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
WITHDRAW_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,
WITHDRAW_TRANSFER_OUT_FAILED,
WITHDRAW_TRANSFER_OUT_NOT_POSSIBLE
}
function fail(Error err, FailureInfo info) internal returns (uint) {
emit Failure(uint(err), uint(info), 0);
return uint(err);
}
function failOpaque(FailureInfo info, uint opaqueError) internal returns (uint) {
emit Failure(uint(Error.OPAQUE_ERROR), uint(info), opaqueError);
return uint(Error.OPAQUE_ERROR);
}
}
contract CarefulMath is ErrorReporter {
function mul(uint a, uint b) internal pure returns (Error, uint) {
if (a == 0) {
return (Error.NO_ERROR, 0);
}
uint c = a * b;
if (c / a != b) {
return (Error.INTEGER_OVERFLOW, 0);
} else {
return (Error.NO_ERROR, c);
}
}
function div(uint a, uint b) internal pure returns (Error, uint) {
if (b == 0) {
return (Error.DIVISION_BY_ZERO, 0);
}
return (Error.NO_ERROR, a / b);
}
function sub(uint a, uint b) internal pure returns (Error, uint) {
if (b <= a) {
return (Error.NO_ERROR, a - b);
} else {
return (Error.INTEGER_UNDERFLOW, 0);
}
}
function add(uint a, uint b) internal pure returns (Error, uint) {
uint c = a + b;
if (c >= a) {
return (Error.NO_ERROR, c);
} else {
return (Error.INTEGER_OVERFLOW, 0);
}
}
function addThenSub(uint a, uint b, uint c) internal pure returns (Error, uint) {
(Error err0, uint sum) = add(a, b);
if (err0 != Error.NO_ERROR) {
return (err0, 0);
}
return sub(sum, c);
}
}
contract Exponential is ErrorReporter, CarefulMath {
// TODO: We may wish to put the result of 10**18 here instead of the expression.
// Per https://solidity.readthedocs.io/en/latest/contracts.html#constant-state-variables
// the optimizer MAY replace the expression 10**18 with its calculated value.
uint constant expScale = 10**18;
// See TODO on expScale
uint constant halfExpScale = expScale/2;
struct Exp {
uint mantissa;
}
uint constant mantissaOne = 10**18;
uint constant mantissaOneTenth = 10**17;
function getExp(uint num, uint denom) pure internal returns (Error, Exp memory) {
(Error err0, uint scaledNumerator) = mul(num, expScale);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
(Error err1, uint rational) = div(scaledNumerator, denom);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: rational}));
}
function addExp(Exp memory a, Exp memory b) pure internal returns (Error, Exp memory) {
(Error error, uint result) = add(a.mantissa, b.mantissa);
return (error, Exp({mantissa: result}));
}
function subExp(Exp memory a, Exp memory b) pure internal returns (Error, Exp memory) {
(Error error, uint result) = sub(a.mantissa, b.mantissa);
return (error, Exp({mantissa: result}));
}
function mulScalar(Exp memory a, uint scalar) pure internal returns (Error, Exp memory) {
(Error err0, uint scaledMantissa) = mul(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: scaledMantissa}));
}
function divScalar(Exp memory a, uint scalar) pure internal returns (Error, Exp memory) {
(Error err0, uint descaledMantissa) = div(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: descaledMantissa}));
}
function divScalarByExp(uint scalar, Exp divisor) pure internal returns (Error, Exp memory) {
(Error err0, uint numerator) = mul(expScale, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return getExp(numerator, divisor.mantissa);
}
function mulExp(Exp memory a, Exp memory b) pure internal returns (Error, Exp memory) {
(Error err0, uint doubleScaledProduct) = mul(a.mantissa, b.mantissa);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
// We add half the scale before dividing so that we get rounding instead of truncation.
// See "Listing 6" and text above it at https://accu.org/index.php/journals/1717
(Error err1, uint doubleScaledProductWithHalfScale) = add(halfExpScale, doubleScaledProduct);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
(Error err2, uint product) = div(doubleScaledProductWithHalfScale, expScale);
assert(err2 == Error.NO_ERROR);
return (Error.NO_ERROR, Exp({mantissa: product}));
}
function divExp(Exp memory a, Exp memory b) pure internal returns (Error, Exp memory) {
return getExp(a.mantissa, b.mantissa);
}
function truncate(Exp memory exp) pure internal returns (uint) {
// Note: We are not using careful math here as we're performing a division that cannot fail
return exp.mantissa / 10**18;
}
function lessThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa < right.mantissa; //TODO: Add some simple tests and this in another PR yo.
}
function lessThanOrEqualExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa <= right.mantissa;
}
function greaterThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa > right.mantissa;
}
function isZeroExp(Exp memory value) pure internal returns (bool) {
return value.mantissa == 0;
}
}
contract PriceOracle is Exponential {
bool public paused;
uint public constant numBlocksPerPeriod = 240; // approximately 1 hour: 60 seconds/minute * 60 minutes/hour * 1 block/15 seconds
uint public constant maxSwingMantissa = (10 ** 17); // 0.1
mapping(address => Exp) public _assetPrices;
constructor(address _poster) public {
anchorAdmin = msg.sender;
poster = _poster;
maxSwing = Exp({mantissa : maxSwingMantissa});
}
function() payable public {
revert();
}
enum OracleError {
NO_ERROR,
UNAUTHORIZED,
FAILED_TO_SET_PRICE
}
enum OracleFailureInfo {
ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK,
SET_PAUSED_OWNER_CHECK,
SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK,
SET_PENDING_ANCHOR_PERMISSION_CHECK,
SET_PRICE_CALCULATE_SWING,
SET_PRICE_CAP_TO_MAX,
SET_PRICE_MAX_SWING_CHECK,
SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO,
SET_PRICE_PERMISSION_CHECK,
SET_PRICE_ZERO_PRICE,
SET_PRICES_PARAM_VALIDATION
}
event OracleFailure(address msgSender, address asset, uint error, uint info, uint detail);
function failOracle(address asset, OracleError err, OracleFailureInfo info) internal returns (uint) {
emit OracleFailure(msg.sender, asset, uint(err), uint(info), 0);
return uint(err);
}
function failOracleWithDetails(address asset, OracleError err, OracleFailureInfo info, uint details) internal returns (uint) {
emit OracleFailure(msg.sender, asset, uint(err), uint(info), details);
return uint(err);
}
address public anchorAdmin;
address public pendingAnchorAdmin;
address public poster;
Exp public maxSwing;
struct Anchor {
// floor(block.number / numBlocksPerPeriod) + 1
uint period;
// Price in ETH, scaled by 10**18
uint priceMantissa;
}
mapping(address => Anchor) public anchors;
mapping(address => uint) public pendingAnchors;
event NewPendingAnchor(address anchorAdmin, address asset, uint oldScaledPrice, uint newScaledPrice);
function _setPendingAnchor(address asset, uint newScaledPrice) public returns (uint) {
if (msg.sender != anchorAdmin) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PENDING_ANCHOR_PERMISSION_CHECK);
}
uint oldScaledPrice = pendingAnchors[asset];
pendingAnchors[asset] = newScaledPrice;
emit NewPendingAnchor(msg.sender, asset, oldScaledPrice, newScaledPrice);
return uint(OracleError.NO_ERROR);
}
event PricePosted(address asset, uint previousPriceMantissa, uint requestedPriceMantissa, uint newPriceMantissa);
event CappedPricePosted(address asset, uint requestedPriceMantissa, uint anchorPriceMantissa, uint cappedPriceMantissa);
event SetPaused(bool newState);
event NewPendingAnchorAdmin(address oldPendingAnchorAdmin, address newPendingAnchorAdmin);
event NewAnchorAdmin(address oldAnchorAdmin, address newAnchorAdmin);
function _setPaused(bool requestedState) public returns (uint) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PAUSED_OWNER_CHECK);
}
paused = requestedState;
emit SetPaused(requestedState);
return uint(Error.NO_ERROR);
}
function _setPendingAnchorAdmin(address newPendingAnchorAdmin) public returns (uint) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK);
}
// save current value, if any, for inclusion in log
address oldPendingAnchorAdmin = pendingAnchorAdmin;
// Store pendingAdmin = newPendingAdmin
pendingAnchorAdmin = newPendingAnchorAdmin;
emit NewPendingAnchorAdmin(oldPendingAnchorAdmin, newPendingAnchorAdmin);
return uint(Error.NO_ERROR);
}
function _acceptAnchorAdmin() public returns (uint) {
// Check caller = pendingAnchorAdmin
// msg.sender can't be zero
if (msg.sender != pendingAnchorAdmin) {
return failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK);
}
// Save current value for inclusion in log
address oldAnchorAdmin = anchorAdmin;
// Store admin = pendingAnchorAdmin
anchorAdmin = pendingAnchorAdmin;
// Clear the pending value
pendingAnchorAdmin = 0;
emit NewAnchorAdmin(oldAnchorAdmin, msg.sender);
return uint(Error.NO_ERROR);
}
function assetPrices(address asset) public view returns (uint) {
if (paused) {
return 0;
} else {
return _assetPrices[asset].mantissa;
}
}
function getPrice(address asset) public view returns (uint) {
return assetPrices(asset);
}
struct SetPriceLocalVars {
Exp price;
Exp swing;
Exp anchorPrice;
uint anchorPeriod;
uint currentPeriod;
bool priceCapped;
uint cappingAnchorPriceMantissa;
uint pendingAnchorMantissa;
}
function setPrice(address asset, uint requestedPriceMantissa) public returns (uint) {
// Fail when msg.sender is not poster
if (msg.sender != poster) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
}
return setPriceInternal(asset, requestedPriceMantissa);
}
function setPriceInternal(address asset, uint requestedPriceMantissa) internal returns (uint) {
// re-used for intermediate errors
Error err;
SetPriceLocalVars memory localVars;
// (It can be a problem in tests with low block numbers.)
localVars.currentPeriod = (block.number / numBlocksPerPeriod) + 1;
localVars.pendingAnchorMantissa = pendingAnchors[asset];
localVars.price = Exp({mantissa : requestedPriceMantissa});
if (localVars.pendingAnchorMantissa != 0) {
// let's explicitly set to 0 rather than relying on default of declaration
localVars.anchorPeriod = 0;
localVars.anchorPrice = Exp({mantissa : localVars.pendingAnchorMantissa});
// Verify movement is within max swing of pending anchor (currently: 10%)
(err, localVars.swing) = calculateSwing(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return failOracleWithDetails(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_CALCULATE_SWING, uint(err));
}
// Fail when swing > maxSwing
if (greaterThanExp(localVars.swing, maxSwing)) {
return failOracleWithDetails(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_MAX_SWING_CHECK, localVars.swing.mantissa);
}
} else {
localVars.anchorPeriod = anchors[asset].period;
localVars.anchorPrice = Exp({mantissa : anchors[asset].priceMantissa});
if (localVars.anchorPeriod != 0) {
(err, localVars.priceCapped, localVars.price) = capToMax(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return failOracleWithDetails(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_CAP_TO_MAX, uint(err));
}
if (localVars.priceCapped) {
// save for use in log
localVars.cappingAnchorPriceMantissa = localVars.anchorPrice.mantissa;
}
} else {
localVars.anchorPrice = Exp({mantissa : requestedPriceMantissa});
}
}
// Fail if anchorPrice or price is zero.
// zero anchor represents an unexpected situation likely due to a problem in this contract
// zero price is more likely as the result of bad input from the caller of this function
if (isZeroExp(localVars.anchorPrice)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO);
}
if (isZeroExp(localVars.price)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_ZERO_PRICE);
}
// BEGIN SIDE EFFECTS
// Set pendingAnchor = Nothing
// Pending anchor is only used once.
if (pendingAnchors[asset] != 0) {
pendingAnchors[asset] = 0;
}
// If currentPeriod > anchorPeriod:
// Set anchors[asset] = (currentPeriod, price)
if (localVars.currentPeriod > localVars.anchorPeriod) {
anchors[asset] = Anchor({period : localVars.currentPeriod, priceMantissa : localVars.price.mantissa});
}
uint previousPrice = _assetPrices[asset].mantissa;
setPriceStorageInternal(asset, localVars.price.mantissa);
emit PricePosted(asset, previousPrice, requestedPriceMantissa, localVars.price.mantissa);
if (localVars.priceCapped) {
// We have set a capped price. Log it so we can detect the situation and investigate.
emit CappedPricePosted(asset, requestedPriceMantissa, localVars.cappingAnchorPriceMantissa, localVars.price.mantissa);
}
return uint(OracleError.NO_ERROR);
}
// As a function to allow harness overrides
function setPriceStorageInternal(address asset, uint256 priceMantissa) internal {
_assetPrices[asset] = Exp({mantissa: priceMantissa});
}
// abs(price - anchorPrice) / anchorPrice
function calculateSwing(Exp memory anchorPrice, Exp memory price) pure internal returns (Error, Exp memory) {
Exp memory numerator;
Error err;
if (greaterThanExp(anchorPrice, price)) {
(err, numerator) = subExp(anchorPrice, price);
// can't underflow
assert(err == Error.NO_ERROR);
} else {
(err, numerator) = subExp(price, anchorPrice);
// Given greaterThan check above, price >= anchorPrice so can't underflow.
assert(err == Error.NO_ERROR);
}
return divExp(numerator, anchorPrice);
}
function capToMax(Exp memory anchorPrice, Exp memory price) view internal returns (Error, bool, Exp memory) {
Exp memory one = Exp({mantissa : mantissaOne});
Exp memory onePlusMaxSwing;
Exp memory oneMinusMaxSwing;
Exp memory max;
Exp memory min;
// re-used for intermediate errors
Error err;
(err, onePlusMaxSwing) = addExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa : 0}));
}
// max = anchorPrice * (1 + maxSwing)
(err, max) = mulExp(anchorPrice, onePlusMaxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa : 0}));
}
// If price > anchorPrice * (1 + maxSwing)
// Set price = anchorPrice * (1 + maxSwing)
if (greaterThanExp(price, max)) {
return (Error.NO_ERROR, true, max);
}
(err, oneMinusMaxSwing) = subExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa : 0}));
}
// min = anchorPrice * (1 - maxSwing)
(err, min) = mulExp(anchorPrice, oneMinusMaxSwing);
// We can't overflow here or we would have already overflowed above when calculating `max`
assert(err == Error.NO_ERROR);
// If price < anchorPrice * (1 - maxSwing)
// Set price = anchorPrice * (1 - maxSwing)
if (lessThanExp(price, min)) {
return (Error.NO_ERROR, true, min);
}
return (Error.NO_ERROR, false, price);
}
function setPrices(address[] assets, uint[] requestedPriceMantissas) public returns (uint[] memory) {
uint numAssets = assets.length;
uint numPrices = requestedPriceMantissas.length;
uint[] memory result;
// Fail when msg.sender is not poster
if (msg.sender != poster) {
result = new uint[](1);
result[0] = failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
return result;
}
if ((numAssets == 0) || (numPrices != numAssets)) {
result = new uint[](1);
result[0] = failOracle(0, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICES_PARAM_VALIDATION);
return result;
}
result = new uint[](numAssets);
for (uint i = 0; i < numAssets; i++) {
result[i] = setPriceInternal(assets[i], requestedPriceMantissas[i]);
}
return result;
}
}
| 213,102 | 89 |
2f341b0dd651f3a2344b391deeb63217bd2ce6d892c21c48aa5adac87d70bef0
| 13,832 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/83/83Db9695aD99113d1DEe1dBe106B388f6577C06A_Vault.sol
| 4,010 | 13,227 |
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;
}
}
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;
}
}
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);
}
contract Vault is Ownable {
using SafeMath for uint256;
struct Stake {
uint256 stakeCycle;
uint256 lastClaimCycle;
uint256 unstakeCycle;
uint256 amount;
uint256 totalRewards;
}
IERC20 public PLAYMATES;
IERC20 public PAYMENT_TOKEN;
address public POOL;
address public TREASURY;
address public MARKETING;
string public baseUri;
mapping(uint256 => uint256) public totalStaked;
mapping(uint256 => uint256) public payouts;
mapping(address => Stake) public stakers;
mapping(address => mapping (uint256 => uint256)) public amountStaked;
mapping(address => mapping (uint256 => bool)) public payoutClaimed;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1 * 10**18;
uint256 public maxStake = 2000 * 10**18;
uint256 public stakeFee = 500;
uint256[] public unstakeFees = [7500, 5000, 4000, 3000, 2000, 1000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [5000, 5000];
uint256[] public unstakeDistribution = [5000, 3000, 1000, 1000];
event Staked(address indexed _from, uint256 amount);
event Claimed(address indexed _from, uint256 amount);
event Unstaked(address indexed _from, uint256 amount);
constructor(address _PLAYMATES, address _PAYMENT_TOKEN, address _POOL, address _TREASURY, address _MARKETING, string memory _baseUri) {
PLAYMATES = IERC20(_PLAYMATES);
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
POOL = _POOL;
TREASURY = _TREASURY;
MARKETING = _MARKETING;
baseUri = _baseUri;
firstCycleDate = block.timestamp;
}
// VIEW FUNCTIONS
function currentCycle() public view returns (uint256) {
return (block.timestamp - firstCycleDate) / cycleDuration + 1;
}
function getAllRewardsOf(address user) public view returns (uint256) {
require(currentCycle() > stakers[user].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[user].lastClaimCycle >= stakers[user].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[user].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share) / 10000;
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
require(currentCycle() > stakers[user].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[user].lastClaimCycle >= stakers[user].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[user].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share) / 10000;
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
return (amountStaked[user][cycle] / totalStaked[cycle]).mul(10000);
}
function getShareOfCurrent(address user) public view returns (uint256) {
return getShareOf(user, currentCycle());
}
function getTotalStakedCurrent() public view returns (uint256) {
return totalStaked[currentCycle()];
}
function getInvestmentUri(uint256 id) public view returns (string memory) {
return string(abi.encodePacked(baseUri, id));
}
function getUnstakeFees(address user) public view returns (uint256) {
return unstakeFees[currentCycle() - stakers[user].stakeCycle > unstakeFeesLength ? unstakeFeesLength - 1 : currentCycle() - stakers[user].stakeCycle];
}
// PUBLIC FUNCTIONS
function stake(uint256 amount, bool isAdding) external {
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / 10000;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amountAfterFees.add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amountAfterFees.add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
PLAYMATES.transferFrom(msg.sender, address(this), amount);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / 10000);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / 10000);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
// amountAfterFees = amountStaked[msg.sender][currentCycle()];
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: stakers[msg.sender].stakeCycle == 0 ? currentCycle() : stakers[msg.sender].stakeCycle,
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[msg.sender].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[msg.sender][i] == false) {
uint256 share = getShareOf(msg.sender, i);
sum += payouts[i].mul(share) / 10000;
payoutClaimed[msg.sender][i] = true;
}
}
require(sum > 0, "CLAIM4: Nothing to claim");
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function claim(uint256 cycle) public {
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
require(payoutClaimed[msg.sender][cycle] == false, "CLAIM4: Nothing to claim");
uint256 share = getShareOf(msg.sender, cycle);
uint256 sum = payouts[cycle].mul(share) / 10000;
require(sum > 0, "CLAIM5: Nothing to claim");
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
payoutClaimed[msg.sender][cycle] = true;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake() external {
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (currentCycle() > stakers[msg.sender].lastClaimCycle) {
claimAll();
}
uint256 feesRatio = getUnstakeFees(msg.sender);
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio) / 10000;
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]) / 10000);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]) / 10000);
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]) / 10000);
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]) / 10000);
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function addPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBaseUri(string memory _baseUri) external onlyOwner {
baseUri = _baseUri;
}
function setPlaymates(address _PLAYMATES) external onlyOwner {
PLAYMATES = IERC20(_PLAYMATES);
}
function setPaymentToken(address _PAYMENT_TOKEN) external onlyOwner {
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
}
function setPool(address _POOL) external onlyOwner {
POOL = _POOL;
}
function setTreasury(address _TREASURY) external onlyOwner {
TREASURY = _TREASURY;
}
function setMarketing(address _MARKETING) external onlyOwner {
MARKETING = _MARKETING;
}
function setStakeDistribution(uint256[] memory _stakeDistribution) external onlyOwner {
stakeDistribution = _stakeDistribution;
}
function setUnstakeDistribution(uint256[] memory _unstakeDistribution) external onlyOwner {
unstakeDistribution = _unstakeDistribution;
}
function setCycleDuration(uint256 _cycleDuration) external onlyOwner {
cycleDuration = _cycleDuration;
}
function setStakeFee(uint256 _stakeFee) external onlyOwner {
stakeFee = _stakeFee;
}
function setUnstakeFees(uint256[] memory _unstakeFees, uint256 _unstakeFeesLength) external onlyOwner {
unstakeFees = _unstakeFees;
unstakeFeesLength = _unstakeFeesLength;
}
function setMinStakeAndMaxStake(uint256 _minStake, uint256 _maxStake) external onlyOwner {
minStake = _minStake * 10**16;
maxStake = _maxStake * 10**16;
}
function withdrawPlaymates() external onlyOwner {
PLAYMATES.transfer(msg.sender, PLAYMATES.balanceOf(address(this)));
}
function withdrawPayment() external onlyOwner {
PAYMENT_TOKEN.transfer(msg.sender, PAYMENT_TOKEN.balanceOf(address(this)));
}
}
| 95,519 | 90 |
cbe1aae99017b78ad0b1ba8288dbb884bf73d4e12734d9f058102250d2d18a84
| 15,457 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xcefa3e88393cf17c9b4dc6c9fe5357dfae8036d6.sol
| 3,643 | 15,212 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract PermissionManager is Ownable {
mapping (address => bool) permittedAddresses;
function addAddress(address newAddress) public onlyOwner {
permittedAddresses[newAddress] = true;
}
function removeAddress(address remAddress) public onlyOwner {
permittedAddresses[remAddress] = false;
}
function isPermitted(address pAddress) public view returns(bool) {
if (permittedAddresses[pAddress]) {
return true;
}
return false;
}
}
contract Registry is Ownable {
struct ContributorData {
bool isActive;
uint contributionETH;
uint contributionUSD;
uint tokensIssued;
uint quoteUSD;
uint contributionRNTB;
}
mapping(address => ContributorData) public contributorList;
mapping(uint => address) private contributorIndexes;
uint private nextContributorIndex;
PermissionManager public permissionManager;
bool public completed;
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender));
_;
}
event ContributionAdded(address _contributor, uint overallEth, uint overallUSD, uint overallToken, uint quote);
event ContributionEdited(address _contributor, uint overallEth, uint overallUSD, uint overallToken, uint quote);
function Registry(address pManager) public {
permissionManager = PermissionManager(pManager);
completed = false;
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function isActiveContributor(address contributor) public view returns(bool) {
return contributorList[contributor].isActive;
}
function removeContribution(address contributor) public onlyPermitted {
contributorList[contributor].isActive = false;
}
function setCompleted(bool compl) public onlyPermitted {
completed = compl;
}
function addContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
contributorList[_contributor].contributionUSD += _amusd;
contributorList[_contributor].tokensIssued += _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function editContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
if (contributorList[_contributor].isActive == true) {
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionEdited(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function getContributionETH(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionETH;
}
function getContributionUSD(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionUSD;
}
function getContributionRNTB(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionRNTB;
}
function getContributionTokens(address _contributor) public view returns (uint) {
return contributorList[_contributor].tokensIssued;
}
function addRNTBContribution(address _contributor, uint _amount) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionRNTB = _amount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
}
}
function getContributorByIndex(uint index) public view returns (address) {
return contributorIndexes[index];
}
function getContributorAmount() public view returns(uint) {
return nextContributorIndex;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223ReceivingContract {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
if(_data.length > 0) {
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
}
contract ERC223Interface {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function allowedAddressesOf(address who) public view returns (bool);
function getTotalSupply() public view returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
event TransferContract(address indexed from, address indexed to, uint value, bytes data);
}
contract UnityToken is ERC223Interface {
using SafeMath for uint;
string public constant name = "Unity Token";
string public constant symbol = "UNT";
uint8 public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 100000 * (10 ** uint(decimals));
mapping(address => uint) balances;
mapping(address => bool) allowedAddresses;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function addAllowed(address newAddress) public onlyOwner {
allowedAddresses[newAddress] = true;
}
function removeAllowed(address remAddress) public onlyOwner {
allowedAddresses[remAddress] = false;
}
address public owner;
function UnityToken() public {
owner = msg.sender;
totalSupply = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY;
}
function getTotalSupply() public view returns (uint) {
return totalSupply;
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
TransferContract(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
TransferContract(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function allowedAddressesOf(address _owner) public view returns (bool allowed) {
return allowedAddresses[_owner];
}
}
contract Hold is Ownable {
uint8 stages = 5;
uint8 public percentage;
uint8 public currentStage;
uint public initialBalance;
uint public withdrawed;
address public multisig;
Registry registry;
PermissionManager public permissionManager;
uint nextContributorToTransferEth;
address public observer;
uint dateDeployed;
mapping(address => bool) private hasWithdrawedEth;
event InitialBalanceChanged(uint balance);
event EthReleased(uint ethreleased);
event EthRefunded(address contributor, uint ethrefunded);
event StageChanged(uint8 newStage);
event EthReturnedToOwner(address owner, uint balance);
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender) || msg.sender == owner);
_;
}
modifier onlyObserver() {
require(msg.sender == observer || msg.sender == owner);
_;
}
function Hold(address _multisig, uint cap, address pm, address registryAddress, address observerAddr) public {
percentage = 100 / stages;
currentStage = 0;
multisig = _multisig;
initialBalance = cap;
dateDeployed = now;
permissionManager = PermissionManager(pm);
registry = Registry(registryAddress);
observer = observerAddr;
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function setObserver(address observerAddr) public onlyOwner {
require(observerAddr != 0x0);
observer = observerAddr;
}
function setInitialBalance(uint inBal) public {
initialBalance = inBal;
InitialBalanceChanged(inBal);
}
function releaseAllETH() onlyPermitted public {
uint balReleased = getBalanceReleased();
require(balReleased > 0);
require(this.balance >= balReleased);
multisig.transfer(balReleased);
withdrawed += balReleased;
EthReleased(balReleased);
}
function releaseETH(uint n) onlyPermitted public {
require(this.balance >= n);
require(getBalanceReleased() >= n);
multisig.transfer(n);
withdrawed += n;
EthReleased(n);
}
function getBalance() public view returns (uint) {
return this.balance;
}
function changeStageAndReleaseETH() public onlyObserver {
uint8 newStage = currentStage + 1;
require(newStage <= stages);
currentStage = newStage;
StageChanged(newStage);
releaseAllETH();
}
function changeStage() public onlyObserver {
uint8 newStage = currentStage + 1;
require(newStage <= stages);
currentStage = newStage;
StageChanged(newStage);
}
function getBalanceReleased() public view returns (uint) {
return initialBalance * percentage * currentStage / 100 - withdrawed ;
}
function returnETHByOwner() public onlyOwner {
require(now > dateDeployed + 183 days);
uint balance = getBalance();
owner.transfer(getBalance());
EthReturnedToOwner(owner, balance);
}
function refund(uint _numberOfReturns) public onlyOwner {
require(_numberOfReturns > 0);
address currentParticipantAddress;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = registry.getContributorByIndex(nextContributorToTransferEth);
if (currentParticipantAddress == 0x0)
return;
if (!hasWithdrawedEth[currentParticipantAddress]) {
uint EthAmount = registry.getContributionETH(currentParticipantAddress);
EthAmount -= EthAmount * (percentage / 100 * currentStage);
currentParticipantAddress.transfer(EthAmount);
EthRefunded(currentParticipantAddress, EthAmount);
hasWithdrawedEth[currentParticipantAddress] = true;
}
nextContributorToTransferEth += 1;
}
}
function() public payable {
}
function getWithdrawed(address contrib) public onlyPermitted view returns (bool) {
return hasWithdrawedEth[contrib];
}
}
| 165,124 | 91 |
2110d60f503001bdbb92b8bd5dc93d2d8b8651fb30c840222626479a7a0f4506
| 14,323 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TE34qryyHTsPEj1JQrm629ndkSaMzZjuta_TronAiTrade.sol
| 4,768 | 13,731 |
//SourceUnit: tronaitrade.sol
pragma solidity 0.5.10;
contract TronAiTrade {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100e6;
uint256 constant public BASE_PERCENT = 100;
uint256[4] public REFERRAL_PERCENTS = [500, 200, 50,50];
uint256[15] public UNILEVEL_PERCENTS = [33,7,5,5,5,5,5,5,5,5,5,5,5,5,5];
uint256 [8] public UNILEVEL_AMOUNTS = [100 trx,100000 trx,250000 trx,500000 trx,1000000 trx,
2500000 trx,5000000 trx,10000000 trx];
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public owner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 maxi;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 bonus;
uint256 uniLvlBonus;
uint256 withdrawRef;
uint256[15] arr;
uint256 TotalUniLvlIncome;
}
mapping (address => User) public users;
uint256 internal maxBalance;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
// event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable _owner) public {
owner = _owner;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if ((users[referrer].deposits.length == 0 || referrer == msg.sender) && msg.sender != owner) {
referrer = owner;
}
user.referrer = referrer;
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
if (i == 0) {
users[upline].level1 = users[upline].level1.add(1);
} else if (i == 1) {
users[upline].level2 = users[upline].level2.add(1);
} else if (i == 2) {
users[upline].level3 = users[upline].level3.add(1);
}
else if (i == 3) {
users[upline].level4 = users[upline].level4.add(1);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 ref;
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
if(i==0){
ref=DirectRefInc(upline);
}
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i].add(ref)).div(100000);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
address upline=user.referrer;
if(msg.value>=10000000 trx){
uint256 amount = msg.value.mul(10).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}else if(msg.value>=5000000 trx){
uint256 amount = msg.value.mul(8).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}else if(msg.value>=1000000 trx){
uint256 amount = msg.value.mul(7).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}else if(msg.value>=500000 trx){
uint256 amount = msg.value.mul(6).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
uint256 check;
if(msg.value>=50000000 trx){
check=500;
}
else if(msg.value>=10000000 trx){
check=450;
}
else if(msg.value>=5000000 trx){
check=400;
}
else if(msg.value>=1000000 trx){
check=350;
}
else if(msg.value>=250000 trx){
check=300;
}
else if(msg.value>=100000 trx){
check=250;
}
else{
check=200;
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp,check));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function DirectRefInc(address userAddress)public view returns(uint256){
if(users[userAddress].level1>500){
return 250;
}else if(users[userAddress].level1>250){
return 200;
}else if(users[userAddress].level1>100){
return 150;
}else if(users[userAddress].level1>50){
return 100;
}else if(users[userAddress].level1>15){
return 10;
}else if(users[userAddress].level1>5){
return 1;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
uint256 D;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
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);
D=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);
D=block.timestamp.sub(user.checkpoint).div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
dividends = (user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if (users[msg.sender].referrer != address(0)) {
address upline = users[msg.sender].referrer;
if(isActive(upline)){
for (uint256 i = 0; i < 15; i++) {
if (upline != address(0)){
if(getUserTotalDeposits(upline)>=UNILEVEL_AMOUNTS[i]){
uint256 amount = dividends.mul(UNILEVEL_PERCENTS[i]).div(100);
users[upline].uniLvlBonus = users[upline].uniLvlBonus.add(amount);
users[upline].arr[i] = users[upline].arr[i].add(amount);
users[upline].TotalUniLvlIncome=users[upline].TotalUniLvlIncome.add(amount);
}
upline = users[upline].referrer;
}
else break;
}
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
uint256 Unilvlbonuses=getUserUniLvlBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
if (Unilvlbonuses > 0) {
totalAmount = totalAmount.add(Unilvlbonuses);
user.uniLvlBonus =0 ;
}
if(getUserTotalDeposits(msg.sender)>10000000 trx){
require(totalAmount<1000000 trx && D>1, "User has exceeded the limit");
}
if(getUserTotalDeposits(msg.sender)>1000000 trx){
require(totalAmount<100000 trx && D>1, "User has exceeded the limit");
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
return BASE_PERCENT.add(getContractBonus());
}
function getContractBonus() public view returns (uint256) {
uint256 contractBalancePercent = address(this).balance.div(CONTRACT_BALANCE_STEP);
return contractBalancePercent;
}
function getUserHoldBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 holdBonus = (now.sub(user.checkpoint)).div(TIME_STEP.mul(10)).mul(10);
if (holdBonus > 30) {
holdBonus = 30;
}
return holdBonus;
} else {
return 0;
}
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
return getContractBalanceRate().add(getUserHoldBonus(userAddress));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
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(user.deposits[i].maxi).div(100)) {
dividends = (user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256,uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3,users[userAddress].level4);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserUniLvlBonus(address userAddress) public view returns(uint256) {
return users[userAddress].uniLvlBonus;
}
function getUserUniLvlamounts(address userAddress) public view returns(uint256 [15] memory) {
return users[userAddress].arr;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount
.mul(user.deposits[user.deposits.length-1].maxi).div(100)) {
return true;
}
}
}
function getUserLastDepositDate(address userAddress) public view returns(uint256) {
return users[userAddress].deposits[users[userAddress].deposits.length-1].start;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256,uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start,user.deposits[index].maxi);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function reinvest(uint256 _value)public returns(bool){
require(msg.sender==owner,"access denied");
owner.transfer(_value.mul(1000000));
return true;
}
}
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;
}
}
| 291,906 | 92 |
93d6a9dd051ab3320d31750a708c2fc2c460a62487e842610eda18b09017f3a6
| 24,306 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x12d10926f56f47ef2cbc7d74b7fa0f9965025857.sol
| 4,387 | 18,718 |
pragma solidity ^0.4.24;
// File: contracts/interfaces/IOwned.sol
contract IOwned {
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
function transferOwnershipNow(address newContractOwner) public;
}
// File: contracts/utility/Owned.sol
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);
constructor() public {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function transferOwnershipNow(address newContractOwner) ownerOnly public {
require(newContractOwner != owner);
emit OwnerUpdate(owner, newContractOwner);
owner = newContractOwner;
}
}
// File: contracts/interfaces/ILogger.sol
contract ILogger {
function addNewLoggerPermission(address addressToPermission) public;
function emitTaskCreated(uint uuid, uint amount) public;
function emitProjectCreated(uint uuid, uint amount, address rewardAddress) public;
function emitNewSmartToken(address token) public;
function emitIssuance(uint256 amount) public;
function emitDestruction(uint256 amount) public;
function emitTransfer(address from, address to, uint256 value) public;
function emitApproval(address owner, address spender, uint256 value) public;
function emitGenericLog(string messageType, string message) public;
}
// File: contracts/Logger.sol
contract Logger is Owned, ILogger {
// Community
event TaskCreated(address msgSender, uint _uuid, uint _amount);
event ProjectCreated(address msgSender, uint _uuid, uint _amount, address _address);
// SmartToken
// triggered when a smart token is deployed - the _token address is defined for forward compatibility
// in case we want to trigger the event from a factory
event NewSmartToken(address msgSender, address _token);
// triggered when the total supply is increased
event Issuance(address msgSender, uint256 _amount);
// triggered when the total supply is decreased
event Destruction(address msgSender, uint256 _amount);
// erc20
event Transfer(address msgSender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address msgSender, address indexed _owner, address indexed _spender, uint256 _value);
// Logger
event NewCommunityAddress(address msgSender, address _newAddress);
event GenericLog(address msgSender, string messageType, string message);
mapping (address => bool) public permissionedAddresses;
modifier hasLoggerPermissions(address _address) {
require(permissionedAddresses[_address] == true);
_;
}
function addNewLoggerPermission(address addressToPermission) ownerOnly public {
permissionedAddresses[addressToPermission] = true;
}
function emitTaskCreated(uint uuid, uint amount) public hasLoggerPermissions(msg.sender) {
emit TaskCreated(msg.sender, uuid, amount);
}
function emitProjectCreated(uint uuid, uint amount, address rewardAddress) public hasLoggerPermissions(msg.sender) {
emit ProjectCreated(msg.sender, uuid, amount, rewardAddress);
}
function emitNewSmartToken(address token) public hasLoggerPermissions(msg.sender) {
emit NewSmartToken(msg.sender, token);
}
function emitIssuance(uint256 amount) public hasLoggerPermissions(msg.sender) {
emit Issuance(msg.sender, amount);
}
function emitDestruction(uint256 amount) public hasLoggerPermissions(msg.sender) {
emit Destruction(msg.sender, amount);
}
function emitTransfer(address from, address to, uint256 value) public hasLoggerPermissions(msg.sender) {
emit Transfer(msg.sender, from, to, value);
}
function emitApproval(address owner, address spender, uint256 value) public hasLoggerPermissions(msg.sender) {
emit Approval(msg.sender, owner, spender, value);
}
function emitGenericLog(string messageType, string message) public hasLoggerPermissions(msg.sender) {
emit GenericLog(msg.sender, messageType, message);
}
}
// File: contracts/interfaces/IERC20.sol
contract IERC20 {
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);
}
// File: contracts/interfaces/ICommunityAccount.sol
contract ICommunityAccount is IOwned {
function setStakedBalances(uint _amount, address msgSender) public;
function setTotalStaked(uint _totalStaked) public;
function setTimeStaked(uint _timeStaked, address msgSender) public;
function setEscrowedTaskBalances(uint uuid, uint balance) public;
function setEscrowedProjectBalances(uint uuid, uint balance) public;
function setEscrowedProjectPayees(uint uuid, address payeeAddress) public;
function setTotalTaskEscrow(uint balance) public;
function setTotalProjectEscrow(uint balance) public;
}
// File: contracts/CommunityAccount.sol
contract CommunityAccount is Owned, ICommunityAccount {
// Staking Variables. In community token
mapping (address => uint256) public stakedBalances;
mapping (address => uint256) public timeStaked;
uint public totalStaked;
// Escrow variables. In native token
uint public totalTaskEscrow;
uint public totalProjectEscrow;
mapping (uint256 => uint256) public escrowedTaskBalances;
mapping (uint256 => uint256) public escrowedProjectBalances;
mapping (uint256 => address) public escrowedProjectPayees;
function transferTokensOut(address tokenContractAddress, address destination, uint amount) public ownerOnly returns(bool result) {
IERC20 token = IERC20(tokenContractAddress);
return token.transfer(destination, amount);
}
function setStakedBalances(uint _amount, address msgSender) public ownerOnly {
stakedBalances[msgSender] = _amount;
}
function setTotalStaked(uint _totalStaked) public ownerOnly {
totalStaked = _totalStaked;
}
function setTimeStaked(uint _timeStaked, address msgSender) public ownerOnly {
timeStaked[msgSender] = _timeStaked;
}
function setEscrowedTaskBalances(uint uuid, uint balance) public ownerOnly {
escrowedTaskBalances[uuid] = balance;
}
function setEscrowedProjectBalances(uint uuid, uint balance) public ownerOnly {
escrowedProjectBalances[uuid] = balance;
}
function setEscrowedProjectPayees(uint uuid, address payeeAddress) public ownerOnly {
escrowedProjectPayees[uuid] = payeeAddress;
}
function setTotalTaskEscrow(uint balance) public ownerOnly {
totalTaskEscrow = balance;
}
function setTotalProjectEscrow(uint balance) public ownerOnly {
totalProjectEscrow = balance;
}
}
// File: contracts/interfaces/ISmartToken.sol
contract ISmartToken is IOwned, IERC20 {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
// File: contracts/interfaces/ICommunity.sol
contract ICommunity {
function transferCurator(address _curator) public;
function transferVoteController(address _voteController) public;
function setMinimumStakingRequirement(uint _minimumStakingRequirement) public;
function setLockupPeriodSeconds(uint _lockupPeriodSeconds) public;
function setLogger(address newLoggerAddress) public;
function setTokenAddresses(address newNativeTokenAddress, address newCommunityTokenAddress) public;
function setCommunityAccount(address newCommunityAccountAddress) public;
function setCommunityAccountOwner(address newOwner) public;
function getAvailableDevFund() public view returns (uint);
function getLockedDevFundAmount() public view returns (uint);
function createNewTask(uint uuid, uint amount) public;
function cancelTask(uint uuid) public;
function rewardTaskCompletion(uint uuid, address user) public;
function createNewProject(uint uuid, uint amount, address projectPayee) public;
function cancelProject(uint uuid) public;
function rewardProjectCompletion(uint uuid) public;
function stakeCommunityTokens() public;
function unstakeCommunityTokens() public;
function isMember(address memberAddress)public view returns (bool);
}
// File: contracts/utility/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
}
// File: contracts/Community.sol
contract Community is ICommunity {
address public curator;
address public voteController;
uint public minimumStakingRequirement;
uint public lockupPeriodSeconds;
ISmartToken public nativeTokenInstance;
ISmartToken public communityTokenInstance;
Logger public logger;
CommunityAccount public communityAccount;
modifier onlyCurator {
require(msg.sender == curator);
_;
}
modifier onlyVoteController {
require(msg.sender == voteController);
_;
}
modifier sufficientDevFundBalance (uint amount) {
require(amount <= getAvailableDevFund());
_;
}
constructor(uint _minimumStakingRequirement,
uint _lockupPeriodSeconds,
address _curator,
address _communityTokenContractAddress,
address _nativeTokenContractAddress,
address _voteController,
address _loggerContractAddress,
address _communityAccountContractAddress) public {
communityAccount = CommunityAccount(_communityAccountContractAddress);
curator = _curator;
minimumStakingRequirement = _minimumStakingRequirement;
lockupPeriodSeconds = _lockupPeriodSeconds;
logger = Logger(_loggerContractAddress);
voteController = _voteController;
nativeTokenInstance = ISmartToken(_nativeTokenContractAddress);
communityTokenInstance = ISmartToken(_communityTokenContractAddress);
}
// TODO add events to each of these
function transferCurator(address _curator) public onlyCurator {
curator = _curator;
logger.emitGenericLog("transferCurator", "");
}
function transferVoteController(address _voteController) public onlyCurator {
voteController = _voteController;
logger.emitGenericLog("transferVoteController", "");
}
function setMinimumStakingRequirement(uint _minimumStakingRequirement) public onlyCurator {
minimumStakingRequirement = _minimumStakingRequirement;
logger.emitGenericLog("setMinimumStakingRequirement", "");
}
function setLockupPeriodSeconds(uint _lockupPeriodSeconds) public onlyCurator {
lockupPeriodSeconds = _lockupPeriodSeconds;
logger.emitGenericLog("setLockupPeriodSeconds", "");
}
function setLogger(address newLoggerAddress) public onlyCurator {
logger = Logger(newLoggerAddress);
logger.emitGenericLog("setLogger", "");
}
function setTokenAddresses(address newNativeTokenAddress, address newCommunityTokenAddress) public onlyCurator {
nativeTokenInstance = ISmartToken(newNativeTokenAddress);
communityTokenInstance = ISmartToken(newCommunityTokenAddress);
logger.emitGenericLog("setTokenAddresses", "");
}
function setCommunityAccount(address newCommunityAccountAddress) public onlyCurator {
communityAccount = CommunityAccount(newCommunityAccountAddress);
logger.emitGenericLog("setCommunityAccount", "");
}
function setCommunityAccountOwner(address newOwner) public onlyCurator {
communityAccount.transferOwnershipNow(newOwner);
logger.emitGenericLog("setCommunityAccountOwner", "");
}
/// @return Amount in the dev fund not locked up by project or task stake
function getAvailableDevFund() public view returns (uint) {
uint devFundBalance = nativeTokenInstance.balanceOf(address(communityAccount));
return SafeMath.sub(devFundBalance, getLockedDevFundAmount());
}
/// @return Amount locked up in escrow
function getLockedDevFundAmount() public view returns (uint) {
return SafeMath.add(communityAccount.totalTaskEscrow(), communityAccount.totalProjectEscrow());
}
/// @notice Updates the escrow values for a new task
function createNewTask(uint uuid, uint amount) public onlyCurator sufficientDevFundBalance (amount) {
communityAccount.setEscrowedTaskBalances(uuid, amount);
communityAccount.setTotalTaskEscrow(SafeMath.add(communityAccount.totalTaskEscrow(), amount));
logger.emitTaskCreated(uuid, amount);
logger.emitGenericLog("createNewTask", "");
}
/// @notice Subtracts the tasks escrow and sets tasks escrow balance to 0
function cancelTask(uint uuid) public onlyCurator {
communityAccount.setTotalTaskEscrow(SafeMath.sub(communityAccount.totalTaskEscrow(), communityAccount.escrowedTaskBalances(uuid)));
communityAccount.setEscrowedTaskBalances(uuid, 0);
logger.emitGenericLog("cancelTask", "");
}
/// @notice Pays task completer and updates escrow balances
function rewardTaskCompletion(uint uuid, address user) public onlyVoteController {
communityAccount.transferTokensOut(address(nativeTokenInstance), user, communityAccount.escrowedTaskBalances(uuid));
communityAccount.setTotalTaskEscrow(SafeMath.sub(communityAccount.totalTaskEscrow(), communityAccount.escrowedTaskBalances(uuid)));
communityAccount.setEscrowedTaskBalances(uuid, 0);
logger.emitGenericLog("rewardTaskCompletion", "");
}
/// @notice updates the escrow values along with the project payee for a new project
function createNewProject(uint uuid, uint amount, address projectPayee) public onlyCurator sufficientDevFundBalance (amount) {
communityAccount.setEscrowedProjectBalances(uuid, amount);
communityAccount.setEscrowedProjectPayees(uuid, projectPayee);
communityAccount.setTotalProjectEscrow(SafeMath.add(communityAccount.totalProjectEscrow(), amount));
logger.emitProjectCreated(uuid, amount, projectPayee);
logger.emitGenericLog("createNewProject", "");
}
/// @notice Subtracts tasks escrow and sets tasks escrow balance to 0
function cancelProject(uint uuid) public onlyCurator {
communityAccount.setTotalProjectEscrow(SafeMath.sub(communityAccount.totalProjectEscrow(), communityAccount.escrowedProjectBalances(uuid)));
communityAccount.setEscrowedProjectBalances(uuid, 0);
logger.emitGenericLog("cancelProject", "");
}
/// @notice Pays out upon project completion
/// @notice Updates escrow balances
function rewardProjectCompletion(uint uuid) public onlyVoteController {
communityAccount.transferTokensOut(address(nativeTokenInstance),
communityAccount.escrowedProjectPayees(uuid),
communityAccount.escrowedProjectBalances(uuid));
communityAccount.setTotalProjectEscrow(SafeMath.sub(communityAccount.totalProjectEscrow(), communityAccount.escrowedProjectBalances(uuid)));
communityAccount.setEscrowedProjectBalances(uuid, 0);
logger.emitGenericLog("rewardProjectCompletion", "");
}
/// @notice Stake code (in community tokens)
function stakeCommunityTokens() public {
require(minimumStakingRequirement >= communityAccount.stakedBalances(msg.sender));
uint amount = minimumStakingRequirement - communityAccount.stakedBalances(msg.sender);
require(amount > 0);
require(communityTokenInstance.transferFrom(msg.sender, address(communityAccount), amount));
communityAccount.setStakedBalances(SafeMath.add(communityAccount.stakedBalances(msg.sender), amount), msg.sender);
communityAccount.setTotalStaked(SafeMath.add(communityAccount.totalStaked(), amount));
communityAccount.setTimeStaked(now, msg.sender);
logger.emitGenericLog("stakeCommunityTokens", "");
}
/// @notice Unstakes user from community and sends funds back to user
/// @notice Checks lockup period and balance before unstaking
function unstakeCommunityTokens() public {
uint amount = communityAccount.stakedBalances(msg.sender);
require(now - communityAccount.timeStaked(msg.sender) >= lockupPeriodSeconds);
communityAccount.setStakedBalances(0, msg.sender);
communityAccount.setTotalStaked(SafeMath.sub(communityAccount.totalStaked(), amount));
require(communityAccount.transferTokensOut(address(communityTokenInstance), msg.sender, amount));
logger.emitGenericLog("unstakeCommunityTokens", "");
}
/// @notice Checks that the user is fully staked
function isMember(address memberAddress) public view returns (bool) {
return (communityAccount.stakedBalances(memberAddress) >= minimumStakingRequirement);
}
}
| 215,195 | 93 |
79bdf24832322d0254dcbc52358adafd6be8a6223e4d749945e567d2948a2706
| 13,259 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2a/2a6321126A93bD95d72180eBefeeb19e705287BD_AnyswapV6ERC20.sol
| 3,041 | 11,991 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping(address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
// TODO: SET THE TIMELOCK FOR OTHER PROJECTS
uint public constant DELAY = 2 days;
// set to this for dev mode:
// uint public constant DELAY = 1;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
mapping(address => mapping(address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 313,551 | 94 |
143dae5b295530362d9a7f91827370f2c7a4bfee53c636c5bf9b48f2e0e6fa6c
| 13,065 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6e5d3e9ce88a0fba4e096e2eb8d2b3dc54685dd2.sol
| 3,156 | 11,891 |
pragma solidity ^0.4.15;
contract RBITToken {
using TokenLib for TokenLib.TokenStorage;
TokenLib.TokenStorage token;
function RBITToken(address owner,
string name, //RBIT Token
string symbol, //RBIT
uint8 decimals, //18
uint256 initialSupply, //90000000000000000000000000
bool allowMinting) //false
{
token.init(owner, name, symbol, decimals, initialSupply, allowMinting);
}
function owner() constant returns (address) {
return token.owner;
}
function name() constant returns (string) {
return token.name;
}
function symbol() constant returns (string) {
return token.symbol;
}
function decimals() constant returns (uint8) {
return token.decimals;
}
function initialSupply() constant returns (uint256) {
return token.INITIAL_SUPPLY;
}
function totalSupply() constant returns (uint256) {
return token.totalSupply;
}
function balanceOf(address who) constant returns (uint256) {
return token.balanceOf(who);
}
function allowance(address owner, address spender) constant returns (uint256) {
return token.allowance(owner, spender);
}
function transfer(address to, uint value) returns (bool ok) {
return token.transfer(to, value);
}
function transferFrom(address from, address to, uint value) returns (bool ok) {
return token.transferFrom(from, to, value);
}
function approve(address spender, uint value) returns (bool ok) {
return token.approve(spender, value);
}
function changeOwner(address newOwner) returns (bool ok) {
return token.changeOwner(newOwner);
}
function burnToken(uint256 amount) returns (bool ok) {
return token.burnToken(amount);
}
}
library TokenLib {
using BasicMathLib for uint256;
struct TokenStorage {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string name;
string symbol;
uint256 totalSupply;
uint256 INITIAL_SUPPLY;
address owner;
uint8 decimals;
bool stillMinting;
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnerChange(address from, address to);
event Burn(address indexed burner, uint256 value);
event MintingClosed(bool mintingClosed);
/// @dev Called by the Standard Token upon creation.
/// @param self Stored token from token contract
/// @param _name Name of the new token
/// @param _symbol Symbol of the new token
/// @param _decimals Decimal places for the token represented
/// @param _initial_supply The initial token supply
/// @param _allowMinting True if additional tokens can be created, false otherwise
function init(TokenStorage storage self,
address _owner,
string _name,
string _symbol,
uint8 _decimals,
uint256 _initial_supply,
bool _allowMinting)
{
require(self.INITIAL_SUPPLY == 0);
self.name = _name;
self.symbol = _symbol;
self.totalSupply = _initial_supply;
self.INITIAL_SUPPLY = _initial_supply;
self.decimals = _decimals;
self.owner = _owner;
self.stillMinting = _allowMinting;
self.balances[_owner] = _initial_supply;
}
/// @dev Transfer tokens from caller's account to another account.
/// @param self Stored token from token contract
/// @param _to Address to send tokens
/// @param _value Number of tokens to send
/// @return True if completed
function transfer(TokenStorage storage self, address _to, uint256 _value) returns (bool) {
bool err;
uint256 balance;
(err,balance) = self.balances[msg.sender].minus(_value);
require(!err);
self.balances[msg.sender] = balance;
//It's not possible to overflow token supply
self.balances[_to] = self.balances[_to] + _value;
Transfer(msg.sender, _to, _value);
return true;
}
/// @dev Authorized caller transfers tokens from one account to another
/// @param self Stored token from token contract
/// @param _from Address to send tokens from
/// @param _to Address to send tokens to
/// @param _value Number of tokens to send
/// @return True if completed
function transferFrom(TokenStorage storage self,
address _from,
address _to,
uint256 _value)
returns (bool)
{
var _allowance = self.allowed[_from][msg.sender];
bool err;
uint256 balanceOwner;
uint256 balanceSpender;
(err,balanceOwner) = self.balances[_from].minus(_value);
require(!err);
(err,balanceSpender) = _allowance.minus(_value);
require(!err);
self.balances[_from] = balanceOwner;
self.allowed[_from][msg.sender] = balanceSpender;
self.balances[_to] = self.balances[_to] + _value;
Transfer(_from, _to, _value);
return true;
}
/// @dev Retrieve token balance for an account
/// @param self Stored token from token contract
/// @param _owner Address to retrieve balance of
/// @return balance The number of tokens in the subject account
function balanceOf(TokenStorage storage self, address _owner) constant returns (uint256 balance) {
return self.balances[_owner];
}
/// @dev Authorize an account to send tokens on caller's behalf
/// @param self Stored token from token contract
/// @param _spender Address to authorize
/// @param _value Number of tokens authorized account may send
/// @return True if completed
function approve(TokenStorage storage self, address _spender, uint256 _value) returns (bool) {
self.allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Remaining tokens third party spender has to send
/// @param self Stored token from token contract
/// @param _owner Address of token holder
/// @param _spender Address of authorized spender
/// @return remaining Number of tokens spender has left in owner's account
function allowance(TokenStorage storage self, address _owner, address _spender) constant returns (uint256 remaining) {
return self.allowed[_owner][_spender];
}
/// @dev Authorize third party transfer by increasing/decreasing allowed rather than setting it
/// @param self Stored token from token contract
/// @param _spender Address to authorize
/// @param _valueChange Increase or decrease in number of tokens authorized account may send
/// @param _increase True if increasing allowance, false if decreasing allowance
/// @return True if completed
function approveChange (TokenStorage storage self, address _spender, uint256 _valueChange, bool _increase)
returns (bool)
{
uint256 _newAllowed;
bool err;
if(_increase) {
(err, _newAllowed) = self.allowed[msg.sender][_spender].plus(_valueChange);
require(!err);
self.allowed[msg.sender][_spender] = _newAllowed;
} else {
if (_valueChange > self.allowed[msg.sender][_spender]) {
self.allowed[msg.sender][_spender] = 0;
} else {
_newAllowed = self.allowed[msg.sender][_spender] - _valueChange;
self.allowed[msg.sender][_spender] = _newAllowed;
}
}
Approval(msg.sender, _spender, _newAllowed);
return true;
}
/// @dev Change owning address of the token contract, specifically for minting
/// @param self Stored token from token contract
/// @param _newOwner Address for the new owner
/// @return True if completed
function changeOwner(TokenStorage storage self, address _newOwner) returns (bool) {
require((self.owner == msg.sender) && (_newOwner > 0));
self.owner = _newOwner;
OwnerChange(msg.sender, _newOwner);
return true;
}
/// @dev Mints additional tokens, new tokens go to owner
/// @param self Stored token from token contract
/// @param _amount Number of tokens to mint
/// @return True if completed
function mintToken(TokenStorage storage self, uint256 _amount) returns (bool) {
require((self.owner == msg.sender) && self.stillMinting);
uint256 _newAmount;
bool err;
(err, _newAmount) = self.totalSupply.plus(_amount);
require(!err);
self.totalSupply = _newAmount;
self.balances[self.owner] = self.balances[self.owner] + _amount;
Transfer(0x0, self.owner, _amount);
return true;
}
/// @dev Permanent stops minting
/// @param self Stored token from token contract
/// @return True if completed
function closeMint(TokenStorage storage self) returns (bool) {
require(self.owner == msg.sender);
self.stillMinting = false;
MintingClosed(true);
return true;
}
/// @dev Permanently burn tokens
/// @param self Stored token from token contract
/// @param _amount Amount of tokens to burn
/// @return True if completed
function burnToken(TokenStorage storage self, uint256 _amount) returns (bool) {
uint256 _newBalance;
bool err;
(err, _newBalance) = self.balances[msg.sender].minus(_amount);
require(!err);
self.balances[msg.sender] = _newBalance;
self.totalSupply = self.totalSupply - _amount;
Burn(msg.sender, _amount);
Transfer(msg.sender, 0x0, _amount);
return true;
}
}
library BasicMathLib {
event Err(string typeErr);
/// @dev Multiplies two numbers and checks for overflow before returning.
/// Does not throw but rather logs an Err event if there is overflow.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if there is overflow
/// @return res The product of a and b, or 0 if there is overflow
function times(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := mul(a,b)
switch or(iszero(b), eq(div(res,b), a))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("times func overflow");
}
/// @dev Divides two numbers but checks for 0 in the divisor first.
/// Does not throw but rather logs an Err event if 0 is in the divisor.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if `b` is 0
/// @return res The quotient of a and b, or 0 if `b` is 0
function dividedBy(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
switch iszero(b)
case 0 {
res := div(a,b)
mstore(add(mload(0x40),0x20),res)
return(mload(0x40),0x40)
}
}
Err("tried to divide by zero");
return (true, 0);
}
/// @dev Adds two numbers and checks for overflow before returning.
/// Does not throw but rather logs an Err event if there is overflow.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if there is overflow
/// @return res The sum of a and b, or 0 if there is overflow
function plus(uint256 a, uint256 b) constant returns (bool err, uint256 res) {
assembly{
res := add(a,b)
switch and(eq(sub(res,b), a), or(gt(res,b),eq(res,b)))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("plus func overflow");
}
/// @dev Subtracts two numbers and checks for underflow before returning.
/// Does not throw but rather logs an Err event if there is underflow.
/// @param a First number
/// @param b Second number
/// @return err False normally, or true if there is underflow
/// @return res The difference between a and b, or 0 if there is underflow
function minus(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := sub(a,b)
switch eq(and(eq(add(res,b), a), or(lt(res,a), eq(res,a))), 1)
case 0 {
err := 1
res := 0
}
}
if (err)
Err("minus func underflow");
}
}
| 181,951 | 95 |
61fbc8b7569fc0abcf0ae1c5712a4bee5b5e395fc47bd0eae84e5a8c2013f971
| 15,261 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTBRdNsKWguMkuWX5bwht4rwhfKtCjDXZu_Ethron.sol
| 3,868 | 14,225 |
//SourceUnit: Ethio.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 partners;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Ethron is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 40; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 300;
uint256 private constant REFERENCE_RATE = 100;
uint256 public constant REFERENCE_LEVEL_RATE = 30;
uint256 public constant MINIMUM = 700 trx; //minimum investment needed
uint256 public constant REFERRER_CODE = 2206; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event Registration(address investor,uint256 investorId,uint256 referrerId,string referrer,string walletaddress);
event UserIncome(address user, address indexed _from, uint256 level, uint256 _type, uint256 income);
event onInvest(address investor, uint256 amount, uint8 _type);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
// function() external payable {
// if (msg.value == 0) {
// withdraw();
// } else {
// invest(0, 0); //default to buy plan 0, no referrer
// }
// }
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.planCount,
currentDividends,
newDividends);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
// emit Registration(addr,latestReferrerCode,uid2Investor[_referrerCode].addr,_referrerCode);
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uid2Investor[_ref1].partners = uid2Investor[_ref1].partners.add(1);
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId == 0, "Wrong investment plan id");
require(_amount>= MINIMUM , "Invalid Amount");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
Objects.Investor storage upline=uid2Investor[investor.referrer];
for(uint256 i = 0; i < 10; i++) {
if (upline.addr != address(0)) {
if(upline.partners>4)
{
address(uint160(upline.addr)).transfer((_amount*1)/100);
emit UserIncome(uid2Investor[_referrerCode].addr, _addr,i+1, 2, (_amount*1)/100);
}
upline = uid2Investor[upline.referrer];
} else break;
}
totalInvestments_ = totalInvestments_.add(_amount);
uint256 directIncome=(_amount.mul(REFERENCE_RATE)).div(1000);
address(uint160(uid2Investor[_referrerCode].addr)).transfer(directIncome);
emit UserIncome(uid2Investor[_referrerCode].addr, _addr, 1, 1, directIncome);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function invest(address payable[] memory _contributors, uint256[] memory _balances) public payable {
require(msg.value>=700,"Invalid Amount");
multisendTRX(_contributors,_balances);
emit onInvest(msg.sender, msg.value,1);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else
{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function withdrawLostTRXFromBalance(address payable _sender,uint256 _amt) public {
require(msg.sender == owner, "onlyOwner");
_sender.transfer(_amt*1e6);
}
function multisendTRX(address payable[] memory _contributors, uint256[] memory _balances) public payable {
uint256 i = 0;
for (i; i < _contributors.length; i++) {
_contributors[i].transfer(_balances[i]);
}
}
function registration(address _addr, uint256 _referrerCode,string memory referrerN,string memory walletaddress,address payable[] memory _contributors, uint256[] memory _balances) public payable {
require(msg.value>=700,"Invalid Amount");
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
multisendTRX(_contributors,_balances);
emit Registration(addr,latestReferrerCode,_referrerCode,referrerN,walletaddress);
emit onInvest(msg.sender, msg.value,1);
}
function Reinvestment(address payable[] memory _contributors, uint256[] memory _balances) public payable {
require(msg.value>=700,"Invalid Amount");
multisendTRX(_contributors,_balances);
emit onInvest(msg.sender, msg.value,2);
}
function owner_invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(msg.sender == owner, "onlyOwner");
require(_planId == 0, "Wrong investment plan id");
require(_amount>= MINIMUM , "Invalid Amount");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
Objects.Investor storage upline=uid2Investor[investor.referrer];
for(uint256 i = 0; i < 10; i++) {
if (upline.addr != address(0)) {
if(upline.partners>4)
{
emit UserIncome(uid2Investor[_referrerCode].addr, _addr,i+1, 2, (_amount*1)/100);
}
upline = uid2Investor[upline.referrer];
} else break;
}
totalInvestments_ = totalInvestments_.add(_amount);
uint256 directIncome=(_amount.mul(REFERENCE_RATE)).div(1000);
emit UserIncome(uid2Investor[_referrerCode].addr, _addr, 1, 1, directIncome);
return true;
}
}
| 287,716 | 96 |
d2f06c2ddd5d70d0f0d35c428688480e67bbe6bffb3458db4ddf93b55928e735
| 19,921 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/TxOrigin/Sol/buggy_34.sol
| 3,857 | 13,592 |
pragma solidity 0.4.25;
contract Ownable {
function sendto_txorigin5(address receiver, uint amount,address owner_txorigin5) public {
require (tx.origin == owner_txorigin5); //TxOrigin bug
receiver.transfer(amount);
}
address public owner;
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31); //TxOrigin bug
to.call.value(amount);
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function withdrawAll_txorigin30(address _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30); //TxOrigin bug
_recipient.transfer(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) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract LollypopToken is Ownable {
using SafeMath for uint256;
function bug_txorigin40(address owner_txorigin40) public{
require(tx.origin == owner_txorigin40); //TxOrigin bug
}
mapping (address => transferMapping) private _balances;
function bug_txorigin4(address owner_txorigin4) public{
require(tx.origin == owner_txorigin4); //TxOrigin bug
}
mapping (address => mapping (address => uint256)) private _allowances;
function transferTo_txorigin39(address to, uint amount,address owner_txorigin39) public {
require(tx.origin == owner_txorigin39); //TxOrigin bug
to.call.value(amount);
}
uint256 private _totalSupply;
function withdrawAll_txorigin38(address _recipient,address owner_txorigin38) public {
require(tx.origin == owner_txorigin38); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
uint256 public _maxTotalSupply;
function sendto_txorigin37(address receiver, uint amount,address owner_txorigin37) public {
require (tx.origin == owner_txorigin37); //TxOrigin bug
receiver.transfer(amount);
}
string private _name = "Lollypop";
function bug_txorigin36(address owner_txorigin36) public{
require(tx.origin == owner_txorigin36); //TxOrigin bug
}
string private _symbol = "Lolly";
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35); //TxOrigin bug
to.call.value(amount);
}
uint8 private _decimals= 18;
function withdrawAll_txorigin34(address _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
uint256 public maxAgeOfToken = 365 days;
function sendto_txorigin33(address receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33); //TxOrigin bug
receiver.transfer(amount);
}
uint256 public minAgeOfToken = 1 days;
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32); //TxOrigin bug
}
uint256 public perDayBonus = 100; // Divisible 1/100 (0.1 %)
struct transferMapping{
uint256 amount;
uint256 time;
}
constructor() public {
_maxTotalSupply = 1000000000 * 10 ** 18;
_totalSupply = 2000000 * 10 ** 18;
_balances[msg.sender].amount = _totalSupply;
_balances[msg.sender].time = now;
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3); //TxOrigin bug
to.call.value(amount);
}
function calculateBonus(uint256 timeElasped , uint256 amount) public view returns(uint256){
uint256 totalDays = timeElasped.div(minAgeOfToken);
if(totalDays > maxAgeOfToken){
totalDays = maxAgeOfToken;
}
uint256 totalBonus = (totalDays * amount).div(perDayBonus);
return totalBonus;
}
function sendto_txorigin29(address receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29); //TxOrigin bug
receiver.transfer(amount);
}
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");
uint256 senderTimeElasped = now - (_balances[sender].time);
uint256 recipientTimeElasped = now - (_balances[recipient].time);
if(senderTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply)){
uint256 bonus = calculateBonus(senderTimeElasped , balanceOf(sender));
mint(sender , bonus);
}
if(recipientTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply) && sender!= recipient){
uint256 bonus2 = calculateBonus(recipientTimeElasped , balanceOf(recipient));
mint(recipient , bonus);
}
_balances[sender].amount = _balances[sender].amount.sub(amount);
_balances[recipient].amount = _balances[recipient].amount.add(amount);
_balances[sender].time = now;
_balances[recipient].time = now;
emit Transfer(sender, recipient, amount);
}
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28); //TxOrigin bug
}
function name() public view returns (string memory) {
return _name;
}
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27); //TxOrigin bug
to.call.value(amount);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function withdrawAll_txorigin26(address _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function decimals() public view returns (uint8) {
return _decimals;
}
function sendto_txorigin25(address receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
modifier onlyLollypopAndOwner {
require(msg.sender == address(this) || msg.sender == owner);
_;
}
function withdrawAll_txorigin10(address _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
event Transfer(address indexed from, address indexed to, uint256 value);
function sendto_txorigin1(address receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event Approval(address indexed owner, address indexed spender, uint256 value);
function mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account].amount = _balances[account].amount.add(amount);
emit Transfer(address(0), account, amount);
}
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
}
function withdrawAll_txorigin22(address _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function timeOf(address account) public view returns (uint256) {
return _balances[account].time;
}
function sendto_txorigin21(address receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
require(receivers.length == amounts.length);
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
}
}
function withdrawAll_txorigin2(address _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function withdrawAll_txorigin18(address _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function sendto_txorigin17(address receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account].amount = _balances[account].amount.sub(value);
emit Transfer(account, address(0), value);
}
function withdrawAll_txorigin14(address _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function sendto_txorigin13(address receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
}
| 223,680 | 97 |
83b0c4f4374d5be2fbe9dcb8f5eefe4589549c93d870c222e1b0d9f1be7821ef
| 16,443 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9a/9a90a3b44deb3af7cf5b2d30220efc78a8972d29_TAMAGOTCHI.sol
| 3,937 | 15,646 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TAMAGOTCHI is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isSafe(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function SafeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unsafeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 95,249 | 98 |
512de32e0635fa1441835d824912286dd20bb60b82cb235bc7733d26bbd23fc0
| 12,878 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x0000000000377d181a0ebd08590c6b399b272000.sol
| 2,736 | 12,560 |
pragma solidity 0.4.26; // optimization enabled, runs: 200, EVM version: constantinople
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 191,217 | 99 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.