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
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
bd8e7095fde06854f23fe3b33ca8849b7774bc9fdca568103c2940d78f84d853
| 27,680 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x696826c18a6bc9be4bbfe3c3a6bb9f5a69388687.sol
| 4,173 | 15,552 |
pragma solidity ^0.4.25;
contract DecentralizationSmartGames{
using SafeMath for uint256;
string public constant name = "Decentralization Smart Games";
string public constant symbol = "DSG";
uint8 public constant decimals = 18;
uint256 public constant tokenPrice = 0.00065 ether;
uint256 public totalSupply;
uint256 public divPerTokenPool;
uint256 public divPerTokenGaming;
uint256 public developmentBalance;
uint256 public charityBalance;
address[2] public owners;
address[2] public candidates;
Fee public fee = Fee(6,4,3,2,1,1,18,65);
Dividends public totalDividends = Dividends(0,0,0);
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => Account) public account;
mapping (address => bool) public games;
struct Account {
uint256 tokenBalance;
uint256 ethereumBalance;
uint256 lastDivPerTokenPool;
uint256 lastDivPerTokenGaming;
uint256 totalDividendsReferrer;
uint256 totalDividendsGaming;
uint256 totalDividendsPool;
address[5] referrer;
bool active;
}
struct Fee{
uint8 r1;
uint8 r2;
uint8 r3;
uint8 r4;
uint8 r5;
uint8 charity;
uint8 development;
uint8 buy;
}
struct Dividends{
uint256 referrer;
uint256 gaming;
uint256 pool;
}
modifier check0x(address address0x) {
require(address0x != address(0), "Address is 0x");
_;
}
modifier checkDSG(uint256 amountDSG) {
require(account[msg.sender].tokenBalance >= amountDSG, "You don't have enough DSG on balance");
_;
}
modifier checkETH(uint256 amountETH) {
require(account[msg.sender].ethereumBalance >= amountETH, "You don't have enough ETH on balance");
_;
}
modifier onlyOwners() {
require(msg.sender == owners[0] || msg.sender == owners[1], "You are not owner");
_;
}
modifier sellTime() {
require(now <= 1560211200, "The sale is over");
_;
}
modifier payDividends(address sender) {
uint256 poolDividends = getPoolDividends();
uint256 gamingDividends = getGamingDividends();
if(poolDividends > 0 && account[sender].active == true){
account[sender].totalDividendsPool = account[sender].totalDividendsPool.add(poolDividends);
account[sender].ethereumBalance = account[sender].ethereumBalance.add(poolDividends);
}
if(gamingDividends > 0 && account[sender].active == true){
account[sender].totalDividendsGaming = account[sender].totalDividendsGaming.add(gamingDividends);
account[sender].ethereumBalance = account[sender].ethereumBalance.add(gamingDividends);
}
_;
account[sender].lastDivPerTokenPool = divPerTokenPool;
account[sender].lastDivPerTokenGaming = divPerTokenGaming;
}
constructor(address owner2) public{
address owner1 = msg.sender;
owners[0] = owner1;
owners[1] = owner2;
account[owner1].active = true;
account[owner2].active = true;
account[owner1].referrer = [owner1, owner1, owner1, owner1, owner1];
account[owner2].referrer = [owner2, owner2, owner2, owner2, owner2];
}
function buy(address referrerAddress) payDividends(msg.sender) sellTime public payable
{
require(msg.value >= 0.1 ether, "Minimum investment is 0.1 ETH");
uint256 forTokensPurchase = msg.value.mul(fee.buy).div(100);
uint256 forDevelopment = msg.value.mul(fee.development).div(100);
uint256 forCharity = msg.value.mul(fee.charity).div(100);
uint256 tokens = forTokensPurchase.mul(10 ** uint(decimals)).div(tokenPrice);
_setReferrer(referrerAddress, msg.sender);
_mint(msg.sender, tokens);
_setProjectDividends(forDevelopment, forCharity);
_distribution(msg.sender, msg.value.mul(fee.r1).div(100), 0);
_distribution(msg.sender, msg.value.mul(fee.r2).div(100), 1);
_distribution(msg.sender, msg.value.mul(fee.r3).div(100), 2);
_distribution(msg.sender, msg.value.mul(fee.r4).div(100), 3);
_distribution(msg.sender, msg.value.mul(fee.r5).div(100), 4);
emit Buy(msg.sender, msg.value, tokens, totalSupply, now);
}
function reinvest(uint256 amountEthereum) payDividends(msg.sender) checkETH(amountEthereum) sellTime public
{
uint256 tokens = amountEthereum.mul(10 ** uint(decimals)).div(tokenPrice);
_mint(msg.sender, tokens);
account[msg.sender].ethereumBalance = account[msg.sender].ethereumBalance.sub(amountEthereum);
emit Reinvest(msg.sender, amountEthereum, tokens, totalSupply, now);
}
function sell(uint256 amountTokens) payDividends(msg.sender) checkDSG(amountTokens) public
{
uint256 ethereum = amountTokens.mul(tokenPrice).div(10 ** uint(decimals));
account[msg.sender].ethereumBalance = account[msg.sender].ethereumBalance.add(ethereum);
_burn(msg.sender, amountTokens);
emit Sell(msg.sender, amountTokens, ethereum, totalSupply, now);
}
function withdraw(uint256 amountEthereum) payDividends(msg.sender) checkETH(amountEthereum) public
{
msg.sender.transfer(amountEthereum);
account[msg.sender].ethereumBalance = account[msg.sender].ethereumBalance.sub(amountEthereum);
emit Withdraw(msg.sender, amountEthereum, now);
}
function gamingDividendsReception() payable external{
require(getGame(msg.sender) == true, "Game not active");
uint256 eth = msg.value;
uint256 forDevelopment = eth.mul(19).div(100);
uint256 forInvesotrs = eth.mul(80).div(100);
uint256 forCharity = eth.div(100);
_setProjectDividends(forDevelopment, forCharity);
_setGamingDividends(forInvesotrs);
}
function _distribution(address senderAddress, uint256 eth, uint8 k) private{
address referrer = account[senderAddress].referrer[k];
uint256 referrerBalance = account[referrer].tokenBalance;
uint256 senderTokenBalance = account[senderAddress].tokenBalance;
uint256 minReferrerBalance = 10000e18;
if(referrerBalance >= minReferrerBalance){
_setReferrerDividends(referrer, eth);
}
else if(k == 0 && referrerBalance < minReferrerBalance && referrer != address(0)){
uint256 forReferrer = eth.mul(referrerBalance).div(minReferrerBalance);
uint256 forPool = eth.sub(forReferrer);
_setReferrerDividends(referrer, forReferrer);
_setPoolDividends(forPool, senderTokenBalance);
}
else{
_setPoolDividends(eth, senderTokenBalance);
}
}
function _setReferrerDividends(address referrer, uint256 eth) private {
account[referrer].ethereumBalance = account[referrer].ethereumBalance.add(eth);
account[referrer].totalDividendsReferrer = account[referrer].totalDividendsReferrer.add(eth);
totalDividends.referrer = totalDividends.referrer.add(eth);
}
function _setReferrer(address referrerAddress, address senderAddress) private
{
if(account[senderAddress].active == false){
require(referrerAddress != senderAddress, "You can't be referrer for yourself");
require(account[referrerAddress].active == true || referrerAddress == address(0), "Your referrer was not found in the contract");
account[senderAddress].referrer = [
referrerAddress,
account[referrerAddress].referrer[0],
account[referrerAddress].referrer[1],
account[referrerAddress].referrer[2],
account[referrerAddress].referrer[3]
];
account[senderAddress].active = true;
emit Referrer(senderAddress,
account[senderAddress].referrer[0],
account[senderAddress].referrer[1],
account[senderAddress].referrer[2],
account[senderAddress].referrer[3],
account[senderAddress].referrer[4],
now);
}
}
function _setProjectDividends(uint256 forDevelopment, uint256 forCharity) private{
developmentBalance = developmentBalance.add(forDevelopment);
charityBalance = charityBalance.add(forCharity);
}
function _setPoolDividends(uint256 amountEthereum, uint256 userTokens) private{
if(amountEthereum > 0){
divPerTokenPool = divPerTokenPool.add(amountEthereum.mul(10 ** uint(decimals)).div(totalSupply.sub(userTokens)));
totalDividends.pool = totalDividends.pool.add(amountEthereum);
}
}
function _setGamingDividends(uint256 amountEthereum) private{
if(amountEthereum > 0){
divPerTokenGaming = divPerTokenGaming.add(amountEthereum.mul(10 ** uint(decimals)).div(totalSupply));
totalDividends.gaming = totalDividends.gaming.add(amountEthereum);
}
}
function setGame(address gameAddress, bool active) public onlyOwners returns(bool){
games[gameAddress] = active;
return true;
}
function getPoolDividends() public view returns(uint256)
{
uint newDividendsPerToken = divPerTokenPool.sub(account[msg.sender].lastDivPerTokenPool);
return account[msg.sender].tokenBalance.mul(newDividendsPerToken).div(10 ** uint(decimals));
}
function getGamingDividends() public view returns(uint256)
{
uint newDividendsPerToken = divPerTokenGaming.sub(account[msg.sender].lastDivPerTokenGaming);
return account[msg.sender].tokenBalance.mul(newDividendsPerToken).div(10 ** uint(decimals));
}
function getAccountData() public view returns(uint256 tokenBalance,
uint256 ethereumBalance,
uint256 lastDivPerTokenPool,
uint256 lastDivPerTokenGaming,
uint256 totalDividendsPool,
uint256 totalDividendsReferrer,
uint256 totalDividendsGaming,
address[5] memory referrer,
bool active)
{
return(account[msg.sender].tokenBalance,
account[msg.sender].ethereumBalance,
account[msg.sender].lastDivPerTokenPool,
account[msg.sender].lastDivPerTokenGaming,
account[msg.sender].totalDividendsPool,
account[msg.sender].totalDividendsReferrer,
account[msg.sender].totalDividendsGaming,
account[msg.sender].referrer,
account[msg.sender].active);
}
function getContractBalance() view public returns (uint256) {
return address(this).balance;
}
function getGame(address gameAddress) view public returns (bool) {
return games[gameAddress];
}
function transferOwnership(address candidate, uint8 k) check0x(candidate) onlyOwners public
{
candidates[k] = candidate;
}
function confirmOwner(uint8 k) public
{
require(msg.sender == candidates[k], "You are not candidate");
owners[k] = candidates[k];
delete candidates[k];
}
function charitytWithdraw(address recipient) onlyOwners check0x(recipient) public
{
recipient.transfer(charityBalance);
delete charityBalance;
}
function developmentWithdraw(address recipient) onlyOwners check0x(recipient) public
{
recipient.transfer(developmentBalance);
delete developmentBalance;
}
function balanceOf(address owner) public view returns(uint256)
{
return account[owner].tokenBalance;
}
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) check0x(spender) checkDSG(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)
{
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, allowed[from][msg.sender]);
return true;
}
function _transfer(address from, address to, uint256 value) payDividends(from) payDividends(to) checkDSG(value) check0x(to) private
{
account[from].tokenBalance = account[from].tokenBalance.sub(value);
account[to].tokenBalance = account[to].tokenBalance.add(value);
if(account[to].active == false) account[to].active = true;
emit Transfer(from, to, value);
}
function _mint(address customerAddress, uint256 value) check0x(customerAddress) private
{
totalSupply = totalSupply.add(value);
account[customerAddress].tokenBalance = account[customerAddress].tokenBalance.add(value);
emit Transfer(address(0), customerAddress, value);
}
function _burn(address customerAddress, uint256 value) check0x(customerAddress) private
{
totalSupply = totalSupply.sub(value);
account[customerAddress].tokenBalance = account[customerAddress].tokenBalance.sub(value);
emit Transfer(customerAddress, address(0), value);
}
event Buy(address indexed customerAddress,
uint256 inputEthereum,
uint256 outputToken,
uint256 totalSupply,
uint256 timestamp);
event Sell(address indexed customerAddress,
uint256 amountTokens,
uint256 outputEthereum,
uint256 totalSupply,
uint256 timestamp);
event Reinvest(address indexed customerAddress,
uint256 amountEthereum,
uint256 outputToken,
uint256 totalSupply,
uint256 timestamp);
event Withdraw(address indexed customerAddress,
uint256 indexed amountEthereum,
uint256 timestamp);
event Referrer(address indexed customerAddress,
address indexed referrer1,
address referrer2,
address referrer3,
address referrer4,
address referrer5,
uint256 timestamp);
event Transfer(address indexed from,
address indexed to,
uint tokens);
event Approval(address indexed tokenOwner,
address indexed spender,
uint tokens);
}
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, "Mul error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "Div error");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "Sub error");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "Add error");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "Mod error");
return a % b;
}
}
| 270,823 | 11,900 |
276158e0670a2282f43433def0e6873316ec381b0fe7c505a032d507963b36fa
| 19,751 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7600998c19453e2a7d911d8c528f50a8928dafce.sol
| 5,291 | 18,577 |
//
pragma solidity ^0.5.0;
interface TeamInterface {
function isOwner() external view returns (bool);
function isAdmin(address _sender) external view returns (bool);
function isDev(address _sender) external view returns (bool);
}
interface PlatformInterface {
function getAllTurnover() external view returns (uint256);
function getTurnover(bytes32 _worksID) external view returns (uint256);
function updateAllTurnover(uint256 _amount) external;
function updateTurnover(bytes32 _worksID, uint256 _amount) external;
function updateFoundAddress(address _foundation) external;
function deposit(bytes32 _worksID) external payable;
function transferTo(address _receiver, uint256 _amount) external;
function getFoundAddress() external view returns (address payable);
function balances() external view returns (uint256);
}
interface ArtistInterface {
function getAddress(bytes32 _artistID) external view returns (address payable);
function add(bytes32 _artistID, address _address) external;
function hasArtist(bytes32 _artistID) external view returns (bool);
function updateAddress(bytes32 _artistID, address _address) external;
}
interface WorksInterface {
function addWorks(bytes32 _worksID,
bytes32 _artistID,
uint8 _debrisNum,
uint256 _price,
uint256 _beginTime)
external;
function configRule(bytes32 _worksID,
uint8 _firstBuyLimit,
uint256 _freezeGap,
uint256 _protectGap,
uint256 _increaseRatio,
uint256 _discountGap,
uint256 _discountRatio,
uint8[3] calldata _firstAllot,
uint8[3] calldata _againAllot,
uint8[3] calldata _lastAllot)
external;
function publish(bytes32 _worksID, uint256 _beginTime) external;
function close(bytes32 _worksID) external;
function getWorks(bytes32 _worksID) external view returns (uint8, uint256, uint256, uint256, bool);
function getDebris(bytes32 _worksID, uint8 _debrisID) external view
returns (uint256, address, address, bytes32, bytes32, uint256);
function getRule(bytes32 _worksID) external view
returns (uint8, uint256, uint256, uint256, uint256, uint256, uint8[3] memory, uint8[3] memory, uint8[3] memory);
function hasWorks(bytes32 _worksID) external view returns (bool);
function hasDebris(bytes32 _worksID, uint8 _debrisID) external view returns (bool);
function isPublish(bytes32 _worksID) external view returns (bool);
function isStart(bytes32 _worksID) external view returns (bool);
function isProtect(bytes32 _worksID, uint8 _debrisID) external view returns (bool);
function isSecond(bytes32 _worksID, uint8 _debrisID) external view returns (bool);
function isGameOver(bytes32 _worksID) external view returns (bool);
function isFinish(bytes32 _worksID, bytes32 _unionID) external view returns (bool);
function hasFirstUnionIds(bytes32 _worksID, bytes32 _unionID) external view returns (bool);
function hasSecondUnionIds(bytes32 _worksID, bytes32 _unionID) external view returns (bool);
function getFirstUnionIds(bytes32 _worksID) external view returns (bytes32[] memory);
function getSecondUnionIds(bytes32 _worksID) external view returns (bytes32[] memory);
function getPrice(bytes32 _worksID) external view returns (uint256);
function getDebrisPrice(bytes32 _worksID, uint8 _debrisID) external view returns (uint256);
function getDebrisStatus(bytes32 _worksID, uint8 _debrisID) external view returns (uint256[4] memory, uint256, bytes32);
function getInitPrice(bytes32 _worksID, uint8 _debrisID) external view returns (uint256);
function getLastPrice(bytes32 _worksID, uint8 _debrisID) external view returns (uint256);
function getLastBuyer(bytes32 _worksID, uint8 _debrisID) external view returns (address payable);
function getLastUnionId(bytes32 _worksID, uint8 _debrisID) external view returns (bytes32);
function getFreezeGap(bytes32 _worksID) external view returns (uint256);
function getFirstBuyLimit(bytes32 _worksID) external view returns (uint256);
function getArtistId(bytes32 _worksID) external view returns (bytes32);
function getDebrisNum(bytes32 _worksID) external view returns (uint8);
function getAllot(bytes32 _worksID, uint8 _flag) external view returns (uint8[3] memory);
function getAllot(bytes32 _worksID, uint8 _flag, uint8 _element) external view returns (uint8);
function getPools(bytes32 _worksID) external view returns (uint256);
function getPoolsAllot(bytes32 _worksID) external view returns (uint256, uint256[3] memory, uint8[3] memory);
function getStartHourglass(bytes32 _worksID) external view returns (uint256);
function getWorksStatus(bytes32 _worksID) external view returns (uint256, uint256, uint256, bytes32);
function getProtectHourglass(bytes32 _worksID, uint8 _debrisID) external view returns (uint256);
function getDiscountHourglass(bytes32 _worksID, uint8 _debrisID) external view returns (uint256);
function updateDebris(bytes32 _worksID, uint8 _debrisID, bytes32 _unionID, address _sender) external;
function updateFirstBuyer(bytes32 _worksID, uint8 _debrisID, bytes32 _unionID, address _sender) external;
function updateBuyNum(bytes32 _worksID, uint8 _debrisID) external;
function finish(bytes32 _worksID, bytes32 _unionID) external;
function updatePools(bytes32 _worksID, uint256 _value) external;
function updateFirstUnionIds(bytes32 _worksID, bytes32 _unionID) external;
function updateSecondUnionIds(bytes32 _worksID, bytes32 _unionID) external;
}
interface PlayerInterface {
function hasAddress(address _address) external view returns (bool);
function hasUnionId(bytes32 _unionID) external view returns (bool);
function getInfoByUnionId(bytes32 _unionID) external view returns (address payable, bytes32, uint256);
function getUnionIdByAddress(address _address) external view returns (bytes32);
function isFreeze(bytes32 _unionID, bytes32 _worksID) external view returns (bool);
function getFirstBuyNum(bytes32 _unionID, bytes32 _worksID) external view returns (uint256);
function getSecondAmount(bytes32 _unionID, bytes32 _worksID) external view returns (uint256);
function getFirstAmount(bytes32 _unionID, bytes32 _worksID) external view returns (uint256);
function getLastAddress(bytes32 _unionID) external view returns (address payable);
function getRewardAmount(bytes32 _unionID, bytes32 _worksID) external view returns (uint256);
function getFreezeHourglass(bytes32 _unionID, bytes32 _worksID) external view returns (uint256);
function getMyReport(bytes32 _unionID, bytes32 _worksID) external view returns (uint256, uint256, uint256);
function getMyStatus(bytes32 _unionID, bytes32 _worksID) external view returns (uint256, uint256, uint256, uint256, uint256);
function getMyWorks(bytes32 _unionID, bytes32 _worksID) external view returns (address, bytes32, uint256, uint256, uint256);
function isLegalPlayer(bytes32 _unionID, address _address) external view returns (bool);
function register(bytes32 _unionID, address _address, bytes32 _worksID, bytes32 _referrer) external returns (bool);
function updateLastAddress(bytes32 _unionID, address payable _sender) external;
function updateLastTime(bytes32 _unionID, bytes32 _worksID) external;
function updateFirstBuyNum(bytes32 _unionID, bytes32 _worksID) external;
function updateSecondAmount(bytes32 _unionID, bytes32 _worksID, uint256 _amount) external;
function updateFirstAmount(bytes32 _unionID, bytes32 _worksID, uint256 _amount) external;
function updateRewardAmount(bytes32 _unionID, bytes32 _worksID, uint256 _amount) external;
function updateMyWorks(bytes32 _unionID,
address _address,
bytes32 _worksID,
uint256 _totalInput,
uint256 _totalOutput) external;
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
library Datasets {
struct Player {
address[] ethAddress;
bytes32 referrer;
address payable lastAddress;
uint256 time;
}
struct MyWorks {
address ethAddress;
bytes32 worksID;
uint256 totalInput;
uint256 totalOutput;
uint256 time;
}
struct Works {
bytes32 worksID;
bytes32 artistID;
uint8 debrisNum;
uint256 price;
uint256 beginTime;
uint256 endTime;
bool isPublish;
bytes32 lastUnionID;
}
struct Debris {
uint8 debrisID;
bytes32 worksID;
uint256 initPrice;
uint256 lastPrice;
uint256 buyNum;
address payable firstBuyer;
address payable lastBuyer;
bytes32 firstUnionID;
bytes32 lastUnionID;
uint256 lastTime;
}
struct Rule {
uint8 firstBuyLimit;
uint256 freezeGap;
uint256 protectGap;
uint256 increaseRatio;
uint256 discountGap;
uint256 discountRatio;
uint8[3] firstAllot;
uint8[3] againAllot;
uint8[3] lastAllot;
}
struct PlayerCount {
uint256 lastTime;
uint256 firstBuyNum;
uint256 firstAmount;
uint256 secondAmount;
uint256 rewardAmount;
}
}
contract PuzzleBID {
using SafeMath for *;
string constant public name = "PuzzleBID Game";
string constant public symbol = "PZB";
TeamInterface private team;
PlatformInterface private platform;
ArtistInterface private artist;
WorksInterface private works;
PlayerInterface private player;
constructor(address _teamAddress,
address _platformAddress,
address _artistAddress,
address _worksAddress,
address _playerAddress) public {
require(_teamAddress != address(0) &&
_platformAddress != address(0) &&
_artistAddress != address(0) &&
_worksAddress != address(0) &&
_playerAddress != address(0));
team = TeamInterface(_teamAddress);
platform = PlatformInterface(_platformAddress);
artist = ArtistInterface(_artistAddress);
works = WorksInterface(_worksAddress);
player = PlayerInterface(_playerAddress);
}
function() external payable {
revert();
}
event OnUpgrade(address indexed _teamAddress,
address indexed _platformAddress,
address indexed _artistAddress,
address _worksAddress,
address _playerAddress);
modifier isHuman() {
address _address = msg.sender;
uint256 _size;
assembly {_size := extcodesize(_address)}
require(_size == 0, "sorry humans only");
_;
}
modifier checkPlay(bytes32 _worksID, uint8 _debrisID, bytes32 _unionID) {
require(msg.value > 0);
require(works.hasWorks(_worksID));
require(works.hasDebris(_worksID, _debrisID));
require(works.isGameOver(_worksID) == false);
require(works.isPublish(_worksID) && works.isStart(_worksID));
require(works.isProtect(_worksID, _debrisID) == false);
require(player.isFreeze(_unionID, _worksID) == false);
if(player.getFirstBuyNum(_unionID, _worksID).add(1) > works.getFirstBuyLimit(_worksID)) {
require(works.isSecond(_worksID, _debrisID));
}
require(msg.value >= works.getDebrisPrice(_worksID, _debrisID));
_;
}
modifier onlyAdmin() {
require(team.isAdmin(msg.sender));
_;
}
function upgrade(address _teamAddress,
address _platformAddress,
address _artistAddress,
address _worksAddress,
address _playerAddress) external onlyAdmin() {
require(_teamAddress != address(0) &&
_platformAddress != address(0) &&
_artistAddress != address(0) &&
_worksAddress != address(0) &&
_playerAddress != address(0));
team = TeamInterface(_teamAddress);
platform = PlatformInterface(_platformAddress);
artist = ArtistInterface(_artistAddress);
works = WorksInterface(_worksAddress);
player = PlayerInterface(_playerAddress);
emit OnUpgrade(_teamAddress, _platformAddress, _artistAddress, _worksAddress, _playerAddress);
}
function startPlay(bytes32 _worksID, uint8 _debrisID, bytes32 _unionID, bytes32 _referrer)
isHuman()
checkPlay(_worksID, _debrisID, _unionID)
external
payable
{
player.register(_unionID, msg.sender, _worksID, _referrer);
uint256 lastPrice = works.getLastPrice(_worksID, _debrisID);
bytes32 lastUnionID = works.getLastUnionId(_worksID, _debrisID);
works.updateDebris(_worksID, _debrisID, _unionID, msg.sender);
player.updateLastTime(_unionID, _worksID);
platform.updateTurnover(_worksID, msg.value);
platform.updateAllTurnover(msg.value);
if(works.isSecond(_worksID, _debrisID)) {
secondPlay(_worksID, _debrisID, _unionID, lastUnionID, lastPrice);
} else {
works.updateBuyNum(_worksID, _debrisID);
firstPlay(_worksID, _debrisID, _unionID);
}
if(works.isFinish(_worksID, _unionID)) {
works.finish(_worksID, _unionID);
finishGame(_worksID);
collectWorks(_worksID, _unionID);
}
}
function firstPlay(bytes32 _worksID, uint8 _debrisID, bytes32 _unionID) private {
works.updateFirstBuyer(_worksID, _debrisID, _unionID, msg.sender);
player.updateFirstBuyNum(_unionID, _worksID);
player.updateFirstAmount(_unionID, _worksID, msg.value);
uint8[3] memory firstAllot = works.getAllot(_worksID, 0);
artist.getAddress(works.getArtistId(_worksID)).transfer(msg.value.mul(firstAllot[0]) / 100);
platform.getFoundAddress().transfer(msg.value.mul(firstAllot[1]) / 100);
works.updatePools(_worksID, msg.value.mul(firstAllot[2]) / 100);
platform.deposit.value(msg.value.mul(firstAllot[2]) / 100)(_worksID);
}
function secondPlay(bytes32 _worksID, uint8 _debrisID, bytes32 _unionID, bytes32 _oldUnionID, uint256 _oldPrice) private {
if(0 == player.getSecondAmount(_unionID, _worksID)) {
works.updateSecondUnionIds(_worksID, _unionID);
}
player.updateSecondAmount(_unionID, _worksID, msg.value);
uint8[3] memory againAllot = works.getAllot(_worksID, 1);
uint256 lastPrice = works.getLastPrice(_worksID, _debrisID);
uint256 commission = lastPrice.mul(againAllot[1]) / 100;
platform.getFoundAddress().transfer(commission);
lastPrice = lastPrice.sub(commission);
if(lastPrice > _oldPrice) {
uint256 overflow = lastPrice.sub(_oldPrice);
artist.getAddress(works.getArtistId(_worksID)).transfer(overflow.mul(againAllot[0]) / 100);
works.updatePools(_worksID, overflow.mul(againAllot[2]) / 100);
platform.deposit.value(overflow.mul(againAllot[2]) / 100)(_worksID);
player.getLastAddress(_oldUnionID).transfer(lastPrice.sub(overflow.mul(againAllot[0]) / 100)
.sub(overflow.mul(againAllot[2]) / 100));
} else {
player.getLastAddress(_oldUnionID).transfer(lastPrice);
}
}
function finishGame(bytes32 _worksID) private {
uint8 lastAllot = works.getAllot(_worksID, 2, 0);
platform.transferTo(msg.sender, works.getPools(_worksID).mul(lastAllot) / 100);
firstSend(_worksID);
secondSend(_worksID);
}
function collectWorks(bytes32 _worksID, bytes32 _unionID) private {
player.updateMyWorks(_unionID, msg.sender, _worksID, 0, 0);
}
function firstSend(bytes32 _worksID) private {
uint8 i;
bytes32[] memory tmpFirstUnionId = works.getFirstUnionIds(_worksID);
address tmpAddress;
uint256 tmpAmount;
uint8 lastAllot = works.getAllot(_worksID, 2, 1);
for(i=0; i<tmpFirstUnionId.length; i++) {
tmpAddress = player.getLastAddress(tmpFirstUnionId[i]);
tmpAmount = player.getFirstAmount(tmpFirstUnionId[i], _worksID);
tmpAmount = works.getPools(_worksID).mul(lastAllot).mul(tmpAmount) / 100 / works.getPrice(_worksID);
platform.transferTo(tmpAddress, tmpAmount);
}
}
function secondSend(bytes32 _worksID) private {
uint8 i;
bytes32[] memory tmpSecondUnionId = works.getSecondUnionIds(_worksID);
address tmpAddress;
uint256 tmpAmount;
uint8 lastAllot = works.getAllot(_worksID, 2, 2);
for(i=0; i<tmpSecondUnionId.length; i++) {
tmpAddress = player.getLastAddress(tmpSecondUnionId[i]);
tmpAmount = player.getSecondAmount(tmpSecondUnionId[i], _worksID);
tmpAmount = works.getPools(_worksID).mul(lastAllot).mul(tmpAmount) / 100 / (platform.getTurnover(_worksID).sub(works.getPrice(_worksID)));
platform.transferTo(tmpAddress, tmpAmount);
}
}
function getNowTime() external view returns (uint256) {
return now;
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 200,759 | 11,901 |
2ab5ddd9707263d3defaac42467df7ec937b82f8f0fefe0775b1dabfc9c862e5
| 11,074 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x623a14b45c676ebd0d8f8d8601153a5a149e8c35.sol
| 2,688 | 10,456 |
pragma solidity ^0.4.24;
// ------ TTT ----- //
contract RBAC {
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role) view public;
function hasRole(address _operator, string _role) view public returns (bool);
function addRole(address _operator, string _role) internal;
function removeRole(address _operator, string _role) internal;
}
contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address _newOwner) external;
}
contract Superuser is Ownable, RBAC {
function addRoleForUser(address _user, string _role) public;
function delRoleForUser(address _user, string _role) public;
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) external;
}
contract OwnerSellContract {
function createOrder(address _owner, uint _amount, uint _price, address _buyer, uint _date) external returns (bool);
function cancelOrder(address _buyer) external returns (bool);
}
contract RealtyContract {
function freezeTokens(address _owner, uint _amount) external returns (bool);
function acceptRequest(address _owner) external returns (bool);
function cancelRequest(address _owner) external returns (bool);
}
contract TTTToken is Superuser {
struct Checkpoint {}
event ClaimedTokens(address indexed _token, address indexed _owner, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
function transfer(address _to, uint256 _amount) external returns (bool);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool);
function doTransfer(address _from, address _to, uint _amount) internal;
function balanceOf(address _owner) public view returns (uint256 balance);
function approve(address _spender, uint256 _amount) public returns (bool);
function increaseApproval(address _spender, uint _addedAmount) external returns (bool);
function decreaseApproval(address _spender, uint _subtractedAmount) external returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) external returns (bool);
function totalSupply() public view returns (uint);
function balanceOfAt(address _owner, uint _blockNumber) public view returns (uint);
function totalSupplyAt(uint _blockNumber) public view returns(uint);
function enableTransfers(bool _transfersEnabled) public returns (bool);
function getValueAt(Checkpoint[] storage checkpoints, uint _block) view internal returns (uint);
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal;
function destroyTokens(address _owner, uint _amount) public returns (bool);
function _doDestroyTokens(address _owner, uint _amount) internal;
function closeProject(uint _price) public;
function getRealty(address _contract, uint _val) public;
function acceptRequest(address _contract, address _owner) public;
function cancelRequest(address _contract, address _owner) public;
function changeTokens() public returns (bool);
function createOrder(address _contract, uint _amount, uint _price, address _buyer, uint _date) public returns (bool);
function cancelOrder(address _contract, address _buyer) public returns (bool);
function min(uint a, uint b) pure internal returns (uint);
function () payable public;
function claimTokens(address _token) external;
}
// ------ TTT ----- //
// ------ USDT ----- //
contract ERC20Basic {
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 {
function transfer(address _to, uint _value) public;
function balanceOf(address _owner) public constant returns (uint balance);
}
contract StandardToken is BasicToken, ERC20 {
function transferFrom(address _from, address _to, uint _value) public;
function approve(address _spender, uint _value) public;
function allowance(address _owner, address _spender) public constant returns (uint remaining);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
function pause() public;
function unpause() public;
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool);
function getOwner() external constant returns (address);
function addBlackList (address _evilUser) public;
function removeBlackList (address _clearedUser) public;
function destroyBlackFunds (address _blackListedUser) public;
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
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 TetherToken is Pausable, StandardToken, BlackList {
function transfer(address _to, uint _value) public;
function transferFrom(address _from, address _to, uint _value) public;
function balanceOf(address who) public constant returns (uint);
function approve(address _spender, uint _value) public;
function allowance(address _owner, address _spender) public constant returns (uint remaining);
function deprecate(address _upgradedAddress) public;
function totalSupply() public constant returns (uint);
function issue(uint amount) public;
function redeem(uint amount) public;
function setParams(uint newBasisPoints, uint newMaxFee) public;
event Issue(uint amount);
event Redeem(uint amount);
event Deprecate(address newAddress);
event Params(uint feeBasisPoints, uint maxFee);
}
// ------ USDT ----- //
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract TTTExchange {
using SafeMath for uint;
TTTToken public tokenTTT = TTTToken(0xF92d38De8e30151835b9Ebe327E52878b4115CBF);
TetherToken public tokenUSD = TetherToken(0xdac17f958d2ee523a2206206994597c13d831ec7);
address owner;
uint priceUSD;
uint priceETH;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
owner = _newOwner;
}
constructor(uint _priceETH, uint _priceUSD) public {
owner = msg.sender;
priceETH = _priceETH;
priceUSD = _priceUSD;
}
function getInfo(address _address) external view returns(uint PriceETH, uint PriceUSD, uint BalanceTTT, uint Approved, uint toETH, uint toUSD) {
PriceETH = priceETH;
PriceUSD = priceUSD;
BalanceTTT = tokenTTT.balanceOf(_address);
Approved = tokenTTT.allowance(_address, address(this));
toETH = Approved * priceETH;
toUSD = Approved * priceUSD;
}
function amIReady(address _address) external view returns(bool) {
uint _a = tokenTTT.allowance(_address, address(this));
if (_a > 0) {
return true;
} else {
return false;
}
}
function() external payable {
msg.sender.transfer(msg.value);
if (uint(bytes(msg.data)[0]) == 1) {
toETH();
}
if (uint(bytes(msg.data)[0]) == 2) {
toUSD();
}
}
function setPriceETH(uint _newPriceETH) external onlyOwner {
require(_newPriceETH != 0);
priceETH = _newPriceETH;
}
function setPriceUSD(uint _newPriceUSD) external onlyOwner {
require(_newPriceUSD != 0);
priceUSD = _newPriceUSD;
}
function toETH() public {
uint _value = tokenTTT.allowance(msg.sender, address(this));
if (_value > 0) {
tokenTTT.transferFrom(msg.sender, owner, _value);
msg.sender.transfer(_value.mul(priceETH));
}
}
function toUSD() public {
uint _value = tokenTTT.allowance(msg.sender, address(this));
if (_value > 0) {
tokenTTT.transferFrom(msg.sender, owner, _value);
tokenUSD.transfer(msg.sender, _value.mul(priceUSD));
}
}
function getBalance(address _recipient) external onlyOwner {
uint _balance = tokenTTT.balanceOf(address(this));
tokenTTT.transfer(_recipient, _balance);
}
}
| 197,871 | 11,902 |
c66d57ac2b1847e77beda7ad6d49fe261543a58e9b206c48ec64056b4644a3fa
| 15,567 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMhKVkqGj87AKk5Qp1M8xcFvsJadbBo2fr_DuoTron.sol
| 4,192 | 14,880 |
//SourceUnit: duotron.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
uint256 match_bonus;
uint256 match_count;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract DuoTron is Ownable {
using SafeMath for uint256;
uint256 public constant REFERENCE_LEVEL1_RATE = 200;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant MINIMUM = 100e6;
uint256 public constant REFERRER_CODE = 1000;
uint256 public constant PLAN_INTEREST = 20;
uint256 public constant PLAN_INTEREST1 = 10;
uint256 public constant PLAN_INTEREST2 = 20;
uint256 public constant PLAN_INTEREST3 = 30;
uint256 public constant PLAN_REINTEREST = 25;
uint256 public constant PLAN_TERM = 105 days;
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256[3][] public matches;
uint256 public constant pool_bonuses=10;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
uint256 uid = address2UID[msg.sender];
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if(investor.planCount>=2){
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_REINTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate,uid2Investor[uid].match_bonus);
}
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
if(investor.plans[i].investmentDate + 5 days == block.timestamp) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST3, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate,uid2Investor[uid].match_bonus);
}
uint256 total_users;
if(latestReferrerCode==1000){
total_users = 1;
}else{
total_users =latestReferrerCode-1000 ;
}
if(total_users==1000)
{
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST1, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate,uid2Investor[uid].match_bonus);
}
if(total_users==10000)
{
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST2, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate,uid2Investor[uid].match_bonus);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate,uid2Investor[uid].match_bonus);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends,
uid2Investor[uid].match_bonus);
}
function tokenDeposit() public payable{
require(msg.sender == owner, "Only owner can use this function");
msg.sender.transfer(address(this).balance);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate,uid2Investor[uid].match_bonus);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
//withdraw
uint256 subAmnt=withdrawalAmount.mul(10).div(100);
msg.sender.transfer(withdrawalAmount.sub(subAmnt));
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start,uint256 _matchAmount) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24)+_matchAmount;
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
if(uid2Investor[_ref1].level1RefCount%2==0){
uint256 amnt=0;
uint256 strt=(uid2Investor[_ref1].level1RefCount-2);
uint256 repeat=2;
uint256 count=0;
uint256 loop=0;
for(uint256 i = 0; i <matches.length ; i++) {
if(matches[i][0]==_referrerCode){
if(count==strt && repeat>loop){
amnt+=matches[i][2];
loop++;
}else{
count++;
}
}
}
uint256 matchPercent=amnt.mul(2).div(100);
uint256 finalAmnt=matchPercent.div(2);
uid2Investor[_ref1].match_bonus += finalAmnt;
}
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 295,534 | 11,903 |
99e6b5b4eb96471e9e77b01ccf6c9c29dda0c241fc1b83e6f1dc39c2002fae07
| 23,040 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3b1ad2987a6dc21678ef80973c2da0d94079651d.sol
| 3,415 | 14,614 |
pragma solidity 0.4.24;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMathLibExt {
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) public pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) public pure returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) public pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract StandardToken is ERC20 {
using SafeMathLibExt for uint;
event Minted(address receiver, uint amount);
mapping(address => uint) public balances;
mapping (address => mapping (address => uint)) public allowed;
function isToken() public pure returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].minus(_value);
balances[_to] = balances[_to].plus(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].plus(_value);
balances[_from] = balances[_from].minus(_value);
allowed[_from][msg.sender] = _allowance.minus(_value);
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) public returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) revert();
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public pure returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
constructor(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if (!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
// Called in a bad state
revert();
}
// Validate input value.
if (value == 0) revert();
balances[msg.sender] = balances[msg.sender].minus(value);
// Take tokens out from circulation
totalSupply = totalSupply.minus(value);
totalUpgraded = totalUpgraded.plus(value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
emit Upgrade(msg.sender, upgradeAgent, value);
}
function canUpgrade() public view returns(bool) {
return true;
}
function setUpgradeAgent(address agent) external {
if (!canUpgrade()) {
// The token is not yet in a state that we could think upgrading
revert();
}
if (agent == 0x0) revert();
// Only a master can designate the next agent
if (msg.sender != upgradeMaster) revert();
// Upgrade has already begun for an agent
if (getUpgradeState() == UpgradeState.Upgrading) revert();
upgradeAgent = UpgradeAgent(agent);
// Bad interface
if (!upgradeAgent.isUpgradeAgent()) revert();
emit UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) revert();
if (msg.sender != upgradeMaster) revert();
upgradeMaster = master;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if (!released) {
if (!transferAgents[_sender]) {
revert();
}
}
_;
}
function setReleaseAgent(address addr) public onlyOwner inReleaseState(false) {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) public onlyOwner inReleaseState(false) {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if (releaseState != released) {
revert();
}
_;
}
modifier onlyReleaseAgent() {
if (msg.sender != releaseAgent) {
revert();
}
_;
}
function transfer(address _to, uint _value) public canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
bool isReserved;
bool isDistributed;
bool isVested;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
bool private reservedTokensDestinationsAreSet = false;
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
if (!mintAgents[msg.sender]) {
revert();
}
_;
}
modifier canMint() {
if (mintingFinished) revert();
_;
}
function finalizeReservedAddress(address addr) public onlyMintAgent canMint {
ReservedTokensData storage reservedTokensData = reservedTokensList[addr];
reservedTokensData.isDistributed = true;
}
function isAddressReserved(address addr) public view returns (bool isReserved) {
return reservedTokensList[addr].isReserved;
}
function areTokensDistributedForAddress(address addr) public view returns (bool isDistributed) {
return reservedTokensList[addr].isDistributed;
}
function getReservedTokens(address addr) public view returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedPercentageUnit(address addr) public view returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedPercentageDecimals(address addr) public view returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function getReservedIsVested(address addr) public view returns (bool isVested) {
return reservedTokensList[addr].isVested;
}
function setReservedTokensListMultiple(address[] addrs,
uint[] inTokens,
uint[] inPercentageUnit,
uint[] inPercentageDecimals,
bool[] isVested) public canMint onlyOwner {
assert(!reservedTokensDestinationsAreSet);
assert(addrs.length == inTokens.length);
assert(inTokens.length == inPercentageUnit.length);
assert(inPercentageUnit.length == inPercentageDecimals.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
if (addrs[iterator] != address(0)) {
setReservedTokensList(addrs[iterator],
inTokens[iterator],
inPercentageUnit[iterator],
inPercentageDecimals[iterator],
isVested[iterator]);
}
}
reservedTokensDestinationsAreSet = true;
}
function mint(address receiver, uint amount) public onlyMintAgent canMint {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
// This will make the mint transaction apper in EtherScan.io
// We can remove this after there is a standardized minting event
emit Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) public onlyOwner canMint {
mintAgents[addr] = state;
emit MintingAgentChanged(addr, state);
}
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals,bool isVested)
private canMint onlyOwner {
assert(addr != address(0));
if (!isAddressReserved(addr)) {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
}
reservedTokensList[addr] = ReservedTokensData({
inTokens: inTokens,
inPercentageUnit: inPercentageUnit,
inPercentageDecimals: inPercentageDecimals,
isReserved: true,
isDistributed: false,
isVested:isVested
});
}
}
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
string public name;
string public symbol;
uint public decimals;
uint public minCap;
constructor(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
public UpgradeableToken(msg.sender) {
// Create any address, can be transferred
// to team multisig via changeOwner(),
// also remember to call setUpgradeMaster()
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
// Create initially all balance on the team multisig
balances[owner] = totalSupply;
if (totalSupply > 0) {
emit Minted(owner, totalSupply);
}
// No more new supply allowed after the token creation
if (!_mintable) {
mintingFinished = true;
if (totalSupply == 0) {
revert(); // Cannot create a token without supply and no minting
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
super.releaseTokenTransfer();
}
function canUpgrade() public view returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) public onlyOwner {
name = _name;
symbol = _symbol;
emit UpdatedTokenInformation(name, symbol);
}
function claimTokens(address _token) public onlyOwner {
require(_token != address(0));
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
}
contract CrowdsaleTokenExtv1 is CrowdsaleTokenExt {
uint public originalSupply;
address public oldTokenAddress;
bool public isUpgradeAgent = false;
constructor(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable,
uint _globalMinCap, address _oldTokenAddress, uint _originalSupply)
public CrowdsaleTokenExt(_name, _symbol, _initialSupply, _decimals, _mintable, _globalMinCap) {
originalSupply = _originalSupply;
oldTokenAddress = _oldTokenAddress;
isUpgradeAgent = true;
}
function upgradeFrom(address _from, uint256 value) public {
// Make sure the call is from old token contract
require(msg.sender == oldTokenAddress);
// Validate input value.
balances[_from] = balances[_from].plus(value);
// Take tokens out from circulation
totalSupply = totalSupply.plus(value);
}
}
| 216,209 | 11,904 |
c45518551f4c212697c74449c5a76eaa0f0b8278ac1a0dbfc81619e0d7c1ab2b
| 12,708 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xd40775e917492a9f8afd740d52770d27682be02d.sol
| 3,491 | 12,558 |
pragma solidity ^0.4.19;
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 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 ERC20 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract WhiteList {
function checkMemberLevel (address addr) view public returns (uint) {}
}
contract PresalePool {
using SafeMath for uint;
uint8 public contractStage = 1;
address public owner;
uint[] public contributionCaps;
uint public feePct;
address public receiverAddress;
uint constant public contributionMin = 100000000000000000;
uint constant public maxGasPrice = 50000000000;
WhiteList constant public whitelistContract = WhiteList(0x8D95B038cA80A986425FA240C3C17Fb2B6e9bc63);
uint public nextCapTime;
uint [] public nextContributionCaps;
uint public addressChangeBlock;
uint public finalBalance;
uint[] public ethRefundAmount;
address public activeToken;
struct Contributor {
bool authorized;
uint ethRefund;
uint balance;
uint cap;
mapping (address => uint) tokensClaimed;
}
mapping (address => Contributor) whitelist;
struct TokenAllocation {
ERC20 token;
uint[] pct;
uint balanceRemaining;
}
mapping (address => TokenAllocation) distributionMap;
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event ReceiverAddressSet (address _addr);
event PoolSubmitted (address receiver, uint amount);
event WithdrawalsOpen (address tokenAddr);
event TokensWithdrawn (address receiver, uint amount);
event EthRefundReceived (address sender, uint amount);
event EthRefunded (address receiver, uint amount);
event ERC223Received (address token, uint value);
function _toPct (uint numerator, uint denominator) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
function PresalePool(address receiverAddr, uint[] capAmounts, uint fee) public {
require (fee < 100);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionCaps = capAmounts;
feePct = _toPct(fee,100);
whitelist[msg.sender].authorized = true;
}
function () payable public {
if (contractStage == 1) {
_ethDeposit();
} else if (contractStage == 3) {
_ethRefund();
} else revert();
}
function _ethDeposit () internal {
assert (contractStage == 1);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= contributionCaps[0]);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
require (newBalance <= _checkCap(msg.sender));
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == receiverAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
}
function withdraw (address tokenAddr) public {
var c = whitelist[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender,tokenAddr);
}
}
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (whitelist[contributor].balance > 0);
_withdraw(contributor,tokenAddr);
}
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require ((ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr]);
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAmount);
}
}
}
function authorize (address addr, uint cap) public onlyOwner {
require (contractStage == 1);
_checkWhitelistContract(addr);
require (!whitelist[addr].authorized);
require ((cap > 0 && cap < contributionCaps.length) || (cap >= contributionMin && cap <= contributionCaps[0]));
uint size;
assembly { size := extcodesize(addr) }
require (size == 0);
whitelist[addr].cap = cap;
whitelist[addr].authorized = true;
}
function authorizeMany (address[] addr, uint cap) public onlyOwner {
require (addr.length < 255);
require (cap > 0 && cap < contributionCaps.length);
for (uint8 i=0; i<addr.length; i++) {
authorize(addr[i], cap);
}
}
function revoke (address addr) public onlyOwner {
require (contractStage < 3);
require (whitelist[addr].authorized);
require (whitelistContract.checkMemberLevel(addr) == 0);
whitelist[addr].authorized = false;
if (whitelist[addr].balance > 0) {
uint amountToTransfer = whitelist[addr].balance;
whitelist[addr].balance = 0;
addr.transfer(amountToTransfer);
ContributorBalanceChanged(addr, 0);
}
}
function modifyIndividualCap (address addr, uint cap) public onlyOwner {
require (contractStage < 3);
require (cap < contributionCaps.length || (cap >= contributionMin && cap <= contributionCaps[0]));
_checkWhitelistContract(addr);
var c = whitelist[addr];
require (c.authorized);
uint amount = c.balance;
c.cap = cap;
uint capAmount = _checkCap(addr);
if (amount > capAmount) {
c.balance = capAmount;
addr.transfer(amount.sub(capAmount));
ContributorBalanceChanged(addr, capAmount);
}
}
function modifyLevelCap (uint level, uint cap) public onlyOwner {
require (contractStage < 3);
require (level > 0 && level < contributionCaps.length);
require (this.balance <= cap && contributionCaps[0] >= cap);
contributionCaps[level] = cap;
nextCapTime = 0;
}
function modifyAllLevelCaps (uint[] cap, uint time) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
require (time == 0 || time>block.timestamp);
if (time == 0) {
for (uint8 i = 0; i < cap.length; i++) {
modifyLevelCap(i+1, cap[i]);
}
} else {
nextContributionCaps = contributionCaps;
nextCapTime = time;
for (i = 0; i < cap.length; i++) {
require (contributionCaps[i+1] <= cap[i] && contributionCaps[0] >= cap[i]);
nextContributionCaps[i+1] = cap[i];
}
}
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
contributionCaps[0] = amount;
nextCapTime = 0;
for (uint8 i=1; i<contributionCaps.length; i++) {
if (contributionCaps[i]>amount) contributionCaps[i]=amount;
}
}
function _checkCap (address addr) internal returns (uint) {
_checkWhitelistContract(addr);
var c = whitelist[addr];
if (!c.authorized) return 0;
if (nextCapTime>0 && block.timestamp>nextCapTime) {
contributionCaps = nextContributionCaps;
nextCapTime = 0;
}
if (c.cap<contributionCaps.length) return contributionCaps[c.cap];
return c.cap;
}
function _checkWhitelistContract (address addr) internal {
var c = whitelist[addr];
if (!c.authorized) {
var level = whitelistContract.checkMemberLevel(addr);
if (level == 0 || level >= contributionCaps.length) return;
c.cap = level;
c.authorized = true;
}
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
if (contractStage == 1) {
remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (contributionCaps[0],this.balance,remaining);
}
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = whitelist[addr];
if (!c.authorized) {
cap = whitelistContract.checkMemberLevel(addr);
if (cap == 0) return (0,0,0);
} else {
cap = c.cap;
}
balance = c.balance;
if (contractStage == 1) {
if (cap<contributionCaps.length) {
if (nextCapTime == 0 || nextCapTime > block.timestamp) {
cap = contributionCaps[cap];
} else {
cap = nextContributionCaps[cap];
}
}
remaining = cap.sub(balance);
if (contributionCaps[0].sub(this.balance) < remaining) remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (balance, cap, remaining);
}
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) {
var c = whitelist[addr];
var d = distributionMap[tokenAddr];
for (uint i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i]));
}
return tokenAmount;
}
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
function setReceiverAddress (address addr) public onlyOwner {
require (addr != 0x00 && receiverAddress == 0x00);
require (contractStage < 3);
receiverAddress = addr;
addressChangeBlock = block.number;
ReceiverAddressSet(addr);
}
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
}
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distributionMap[tokenAddr];
if (d.pct.length==0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount,finalBalance));
}
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received (from, value);
}
}
| 276,553 | 11,905 |
4e5c1a15dfaab205aec99cce01ad3244e7f2ef80b69de18690d24857469bfe36
| 19,562 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x2c1564a74f07757765642acef62a583b38d5a213_affectedByMiners.sol
| 3,506 | 13,265 |
pragma solidity ^0.5.7;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address internal _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(msg.sender == _owner);
_;
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0));
_owner = newOwner;
emit OwnershipTransferred(_owner, newOwner);
}
function rescueTokens(address tokenAddr, address receiver, uint256 amount) external onlyOwner {
IERC20 _token = IERC20(tokenAddr);
require(receiver != address(0));
uint256 balance = _token.balanceOf(address(this));
require(balance >= amount);
assert(_token.transfer(receiver, amount));
}
function withdrawEther(address payable to, uint256 amount) external onlyOwner {
require(to != address(0));
uint256 balance = address(this).balance;
require(balance >= amount);
to.transfer(amount);
}
}
contract Pausable is Ownable {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() external onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() external onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract Wesion is Ownable, Pausable, IERC20 {
using SafeMath for uint256;
string private _name = "Wesion";
string private _symbol = "Wesion";
uint8 private _decimals = 6; // 6 decimals
uint256 private _cap = 35000000000000000; // 35 billion cap, that is 35000000000.000000
uint256 private _totalSupply;
mapping (address => bool) private _minter;
event Mint(address indexed to, uint256 value);
event MinterChanged(address account, bool state);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
bool private _allowWhitelistRegistration;
mapping(address => address) private _referrer;
mapping(address => uint256) private _refCount;
event WesionSaleWhitelistRegistered(address indexed addr, address indexed refAddr);
event WesionSaleWhitelistTransferred(address indexed previousAddr, address indexed _newAddr);
event WesionSaleWhitelistRegistrationEnabled();
event WesionSaleWhitelistRegistrationDisabled();
uint256 private _whitelistRegistrationValue = 1001000000; // 1001 Wesion, 1001.000000
uint256[15] private _whitelistRefRewards = [ // 100% Reward
301000000, // 301 Wesion for Level.1
200000000, // 200 Wesion for Level.2
100000000, // 100 Wesion for Level.3
100000000, // 100 Wesion for Level.4
100000000, // 100 Wesion for Level.5
50000000, // 50 Wesion for Level.6
40000000, // 40 Wesion for Level.7
30000000, // 30 Wesion for Level.8
20000000, // 20 Wesion for Level.9
10000000, // 10 Wesion for Level.10
10000000, // 10 Wesion for Level.11
10000000, // 10 Wesion for Level.12
10000000, // 10 Wesion for Level.13
10000000, // 10 Wesion for Level.14
10000000 // 10 Wesion for Level.15
];
event Donate(address indexed account, uint256 amount);
event WithdrawToken(address indexed from, address indexed to, uint256 value);
constructor() public {
_minter[msg.sender] = true;
_allowWhitelistRegistration = true;
emit WesionSaleWhitelistRegistrationEnabled();
_referrer[msg.sender] = msg.sender;
emit WesionSaleWhitelistRegistered(msg.sender, msg.sender);
}
function () external payable {
emit Donate(msg.sender, msg.value);
}
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 cap() public view returns (uint256) {
return _cap;
}
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 whenNotPaused returns (bool) {
if (_allowWhitelistRegistration && value == _whitelistRegistrationValue
&& inWhitelist(to) && !inWhitelist(msg.sender) && isNotContract(msg.sender)) {
// Register whitelist for Wesion-Sale
_regWhitelist(msg.sender, to);
return true;
} else {
// Normal Transfer
_transfer(msg.sender, to, value);
return true;
}
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, 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 transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
require(_allowed[from][msg.sender] >= value);
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
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 _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0));
require(spender != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
modifier onlyMinter() {
require(_minter[msg.sender]);
_;
}
function isMinter(address account) public view returns (bool) {
return _minter[account];
}
function setMinterState(address account, bool state) external onlyOwner {
_minter[account] = state;
emit MinterChanged(account, state);
}
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
function _mint(address account, uint256 value) internal {
require(_totalSupply.add(value) <= _cap);
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Mint(account, value);
emit Transfer(address(0), account, value);
}
modifier onlyInWhitelist() {
require(_referrer[msg.sender] != address(0));
_;
}
function allowWhitelistRegistration() public view returns (bool) {
return _allowWhitelistRegistration;
}
function inWhitelist(address account) public view returns (bool) {
return _referrer[account] != address(0);
}
function referrer(address account) public view returns (address) {
return _referrer[account];
}
function refCount(address account) public view returns (uint256) {
return _refCount[account];
}
function disableWesionSaleWhitelistRegistration() external onlyOwner {
_allowWhitelistRegistration = false;
emit WesionSaleWhitelistRegistrationDisabled();
}
function _regWhitelist(address account, address refAccount) internal {
_refCount[refAccount] = _refCount[refAccount].add(1);
_referrer[account] = refAccount;
emit WesionSaleWhitelistRegistered(account, refAccount);
// Whitelist Registration Referral Reward
_transfer(msg.sender, address(this), _whitelistRegistrationValue);
address cursor = account;
uint256 remain = _whitelistRegistrationValue;
uint256 _rebackToContract = 0;
for(uint i = 0; i < _whitelistRefRewards.length; i++) {
address receiver = _referrer[cursor];
if (block.coinbase != receiver) { //injected CONTRACT AFFECTED BY MINERS
if (block.number > i) { //injected CONTRACT AFFECTED BY MINERS
_transfer(address(this), receiver, _whitelistRefRewards[i]);
remain = remain.sub(_whitelistRefRewards[i]);
}
else {
_rebackToContract = _rebackToContract.add(_whitelistRefRewards[i]);
remain = remain.sub(_whitelistRefRewards[i]);
continue;
}
} else {
_rebackToContract = _rebackToContract.add(remain);
break;
}
cursor = _referrer[cursor];
}
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
_transfer(address(this), address(this), _rebackToContract);
}
}
function transferWhitelist(address account) external onlyInWhitelist {
require(isNotContract(account));
_refCount[account] = _refCount[msg.sender];
_refCount[msg.sender] = 0;
_referrer[account] = _referrer[msg.sender];
_referrer[msg.sender] = address(0);
emit WesionSaleWhitelistTransferred(msg.sender, account);
}
function isNotContract(address addr) internal view returns (bool) {
uint size;
assembly {
size := extcodesize(addr)
}
return size == 0;
}
function calculateTheRewardOfDirectWhitelistRegistration(address whitelistedAccount) external view returns (uint256 reward) {
if (!inWhitelist(whitelistedAccount)) {
return 0;
}
address cursor = whitelistedAccount;
uint256 remain = _whitelistRegistrationValue;
for(uint i = 1; i < _whitelistRefRewards.length; i++) {
address receiver = _referrer[cursor];
if (block.coinbase != receiver) { //injected CONTRACT AFFECTED BY MINERS
if (block.number > i) { //injected CONTRACT AFFECTED BY MINERS
remain = remain.sub(_whitelistRefRewards[i]);
}
} else {
reward = reward.add(remain);
break;
}
cursor = _referrer[cursor];
}
return reward;
}
function withdrawToken(address _to, uint256 _value) public onlyOwner {
require (_value > 0);
require (_to != address(0));
_transfer(address(this), _to, _value);
emit WithdrawToken(address(this), _to, _value);
}
}
| 280,765 | 11,906 |
4e6ba4c8866b464f8cdff2955ca774fa2105c616fae287429285fbb161072f86
| 23,965 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFcMm1eW3YUZ8TwpgtYL7RABxefKDjSh6M_TronMine.sol
| 6,081 | 22,257 |
//SourceUnit: tronmineLive.sol
pragma solidity 0.5.8;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract TronMine {
using SafeMath for uint;
struct UserStruct{ // user struct
bool isExist;
uint id;
uint actualRefID;
uint referrerID;
uint package;
uint totalTopUpInvest;
uint topupCount;
uint cellingPackage;
uint celling;
uint expiry;
uint totalEarned;
uint[] referrals;
uint8 blocked; // 1- unblock 2- block
uint created;
uint8 rewardStatus; // 0- not received 1- received
}
struct InvestmentStruct{ // user investments
uint initialInvestment;
uint directBonusEarned;
uint binaryInvestment;
uint binaryEarned;
uint topUpBinaryEarned;
uint ROIEarned;
uint totalInvestments;
uint investID;
mapping(uint => InvestmentInfoStruct) investInfo;
}
struct InvestmentInfoStruct{
uint investAmount;
uint time;
uint8 flag; // 1- reg, 2 - topup, 3- repack
}
// struct Invest
struct PackageStruct{
uint packagePrice;
uint packageExpiry;
uint celling;
uint ROI;
}
address public ownerWallet;
address public distributor;
uint public currentUserID;
uint REFERRER_1_LEVEL_LIMIT = 2;
uint minimumTopUp = 5000 trx;
uint rewardValue = 5000000 trx;
uint public lockStatus = 1;
mapping(uint => UserStruct) public users; // users mapping;
mapping(uint => InvestmentStruct) public userInvestments; // investment mapping;
mapping (uint => uint) public dailyPayout;
mapping (uint => uint) public dailyPayoutTime;
mapping(uint => address) public usersList; // users address by id;
mapping(address => uint[]) public userIDList; // view user id's by user address
mapping(uint => PackageStruct) public packages; // packages
// Events
event regUserEvent(address indexed _user, uint _userID, address indexed _referrer, uint _referrerID, uint _initialInvestment, uint _time);
event rePackageEvent(address indexed _user, uint _userID, uint _package, uint _investment, uint _time);
event topUpEvent(address indexed _user, uint _userID, uint _initialInvestment, uint _time);
event directBonusEvent(address indexed _user, uint _userID, address indexed _referrer, uint _referrerID, uint _bonus, uint _time);
event binaryCommissionEvent(address indexed _user, uint _userID, uint _binaryPayout, uint _time);
event ROIEvent(address indexed _user, uint indexed _userID, uint _amount, uint _time);
event topUpBinaryEvent(address indexed _user, uint indexed _userID, uint _payout, uint _leftBinaryAmount, uint _righttBinaryAmount, uint _time);
event rewardEvent(address indexed _user, uint _userID, uint _amount, uint _time);
constructor(address _distributor)public{
ownerWallet = msg.sender;
distributor = _distributor;
packages[1].packagePrice = 1000 trx;
packages[2].packagePrice = 3000 trx;
packages[3].packagePrice = 15000 trx;
packages[4].packagePrice = 30000 trx;
packages[5].packagePrice = 50000 trx;
packages[1].packageExpiry = 100 days;
packages[2].packageExpiry = 136 days;
packages[3].packageExpiry = 117 days;
packages[4].packageExpiry = 102 days;
packages[5].packageExpiry = 102 days;
packages[1].celling = 1000 trx;
packages[2].celling = 3000 trx;
packages[3].celling = 15000 trx;
packages[4].celling = 30000 trx;
packages[5].celling = 50000 trx;
packages[1].ROI = 0;
packages[2].ROI = 1.5 trx;
packages[3].ROI = 1.75 trx;
packages[4].ROI = 2 trx;
packages[5].ROI = 2 trx;
currentUserID++;
usersList[currentUserID] = ownerWallet;
UserStruct memory userStruct;
userStruct = UserStruct({
isExist : true,
id : currentUserID,
actualRefID: 0,
referrerID : 0,
package : 5,
totalTopUpInvest: 0,
topupCount: 0,
cellingPackage: 5,
celling : packages[5].celling,
expiry: 55555555555,
totalEarned:0,
blocked:1,
created: now.add(30 days),
rewardStatus:0,
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userIDList[ownerWallet].push(currentUserID);
dailyPayoutTime[currentUserID] = now;
}
function regUser(uint _referrerID, uint _package) public payable {
require(lockStatus == 1,"Contract Locked");
require((userIDList[msg.sender].length == 0), "user exist in previous ID");
require((_referrerID != 0) && (users[_referrerID].isExist), "invalid referrer address");
require((_package > 0) && (_package <= 5), "invalid package id");
require(msg.value == packages[_package].packagePrice, "invalid value");
uint orginalID = _referrerID;
if(users[_referrerID].referrals.length >= REFERRER_1_LEVEL_LIMIT)
_referrerID = users[findFreeReferrer(_referrerID)].id;
currentUserID++;
UserStruct memory userStruct;
InvestmentStruct memory investStruct;
userStruct = UserStruct({
isExist : true,
id : currentUserID,
actualRefID : orginalID,
referrerID : _referrerID,
package : _package,
totalTopUpInvest: packages[_package].celling,
topupCount: 0,
cellingPackage: _package,
celling : packages[_package].celling,
expiry: now.add(packages[_package].packageExpiry),
totalEarned:0,
blocked:1,
created: now.add(30 days),
rewardStatus:0,
referrals : new uint[](0)
});
investStruct = InvestmentStruct({
initialInvestment : msg.value,
directBonusEarned : 0,
binaryInvestment : msg.value,
binaryEarned : 0,
topUpBinaryEarned:0,
ROIEarned : 0,
totalInvestments : msg.value,
investID:1
});
users[currentUserID] = userStruct;
usersList[currentUserID] = msg.sender;
userInvestments[currentUserID] = investStruct;
userInvestments[currentUserID].investInfo[userInvestments[currentUserID].investID].investAmount = msg.value;
userInvestments[currentUserID].investInfo[userInvestments[currentUserID].investID].time = now;
userInvestments[currentUserID].investInfo[userInvestments[currentUserID].investID].flag = 1;
userIDList[msg.sender].push(currentUserID);
dailyPayoutTime[currentUserID] = now;
users[_referrerID].referrals.push(currentUserID);
directBonus(users[currentUserID].actualRefID, currentUserID); // referral bonus
emit regUserEvent(msg.sender, currentUserID, usersList[_referrerID], _referrerID, userInvestments[currentUserID].initialInvestment, now);
}
function topUp() external payable{
require(lockStatus == 1,"Contract Locked");
require(userIDList[msg.sender].length > 0, "user not exist");
require(msg.value > 0, "value must be greater than zero");
require(msg.value >= minimumTopUp, "value must be greater than or equal to minimumTopUp");
uint _TopUpCount = (msg.value.div(minimumTopUp));
require(msg.value == minimumTopUp.mul(_TopUpCount), "invalid amount");
uint _userID = userIDList[msg.sender][userIDList[msg.sender].length-1];
require(users[_userID].blocked == 1, "user is not in active state");
users[_userID].topupCount++;
userInvestments[_userID].binaryInvestment = userInvestments[_userID].binaryInvestment.add(msg.value);
userInvestments[_userID].totalInvestments = userInvestments[_userID].totalInvestments.add(msg.value);
userInvestments[_userID].investID++;
userInvestments[_userID].investInfo[userInvestments[_userID].investID].investAmount = msg.value;
userInvestments[_userID].investInfo[userInvestments[_userID].investID].time = now;
userInvestments[_userID].investInfo[userInvestments[_userID].investID].flag = 2;
uint _celling = checkCelling(users[_userID].celling);
users[_userID].totalTopUpInvest += msg.value;
if(users[_userID].celling < users[_userID].totalTopUpInvest){
_celling = checkCelling(users[_userID].totalTopUpInvest);
users[_userID].celling = packages[_celling].celling;
}
if((users[_userID].topupCount == 1) && (users[_userID].cellingPackage == 1)){
users[_userID].expiry = now.add(packages[_celling].packageExpiry);
users[_userID].cellingPackage = _celling;
}
else
users[_userID].expiry = now.add(packages[users[_userID].cellingPackage].packageExpiry);
emit topUpEvent(msg.sender, _userID, msg.value, now);
}
function rePackage(uint _package) public payable returns(bool){
require(lockStatus == 1,"Contract Locked");
require(userIDList[msg.sender].length > 0, "user not exist");
require(msg.value == packages[_package].packagePrice, "invalid value");
uint _userID = userIDList[msg.sender][userIDList[msg.sender].length-1];
require(users[_userID].blocked == 2, "user is not in inactive state");
users[_userID].package = _package;
users[_userID].cellingPackage = _package;
users[_userID].celling = packages[_package].celling;
users[_userID].totalTopUpInvest = packages[_package].celling;
userInvestments[_userID].binaryInvestment = userInvestments[_userID].binaryInvestment.add(msg.value);
userInvestments[_userID].totalInvestments = userInvestments[_userID].totalInvestments.add(msg.value);
userInvestments[_userID].investID++;
userInvestments[_userID].investInfo[userInvestments[_userID].investID].investAmount = msg.value;
userInvestments[_userID].investInfo[userInvestments[_userID].investID].time = now;
userInvestments[_userID].investInfo[userInvestments[_userID].investID].flag = 3;
users[_userID].topupCount = 0;
users[_userID].blocked = 1;
users[_userID].expiry = now.add(packages[users[_userID].cellingPackage].packageExpiry);
dailyPayoutTime[_userID] = now;
emit rePackageEvent(msg.sender, _userID, _package, msg.value, now);
return true;
}
function checkCelling(uint _amount) internal view returns(uint){
if((_amount >= packages[1].celling) && (_amount < packages[2].celling))
return 1;
else if((_amount >= packages[2].celling) && (_amount < packages[3].celling))
return 2;
else if((_amount >= packages[3].celling) && (_amount < packages[4].celling))
return 3;
else if((_amount >= packages[4].celling) && (_amount < packages[5].celling))
return 4;
else
return 5;
}
function injectUsers(address[] memory _users, uint[] memory _refID, uint[] memory _package) public returns(bool){
require(msg.sender == distributor, "only distributor");
require(_users.length == _refID.length && _refID.length == _package.length, "invalid length");
uint orginalID;
for(uint i=0;i<_users.length;i++){
require((_refID[i] != 0) && (users[_refID[i]].isExist), "invalid referrer address");
require((_package[i] > 0) && (_package[i] <= 5), "invalid package id");
require(users[_refID[i]].isExist == true, "referrer not exist");
require((userIDList[_users[i]].length == 0), "user already exist");
orginalID = _refID[i];
if(users[_refID[i]].referrals.length >= REFERRER_1_LEVEL_LIMIT)
_refID[i] = users[findFreeReferrer(_refID[i])].id;
currentUserID++;
UserStruct memory userStruct;
InvestmentStruct memory investStruct;
userStruct = UserStruct({
isExist : true,
id : currentUserID,
actualRefID : orginalID,
referrerID : _refID[i],
package : _package[i],
totalTopUpInvest: packages[_package[i]].celling,
topupCount: 0,
cellingPackage : _package[i],
celling : packages[_package[i]].celling,
expiry: now.add(packages[_package[i]].packageExpiry),
totalEarned:0,
blocked:1,
created: now.add(30 days),
rewardStatus:0,
referrals : new uint[](0)
});
investStruct = InvestmentStruct({
initialInvestment : 0,
directBonusEarned : 0,
binaryInvestment : 0,
binaryEarned : 0,
topUpBinaryEarned:0,
ROIEarned : 0,
totalInvestments : 0 ,
investID:0
});
users[currentUserID] = userStruct;
usersList[currentUserID] = _users[i];
userInvestments[currentUserID] = investStruct;
userIDList[_users[i]].push(currentUserID);
dailyPayoutTime[currentUserID] = now;
users[_refID[i]].referrals.push(currentUserID);
emit regUserEvent(_users[i], currentUserID, usersList[_refID[i]], _refID[i], userInvestments[currentUserID].initialInvestment, now);
}
}
function updatedPackageExpiry(uint _package, uint _days) public returns(bool){
require(msg.sender == ownerWallet,"Only ownerWallet");
packages[_package].packageExpiry = _days;
return true;
}
function contractLock(uint _lockStatus) public returns (bool) {
require(msg.sender == ownerWallet, "Invalid User");
require(_lockStatus ==1 || _lockStatus == 2);
lockStatus = _lockStatus;
return true;
}
function failSafe(address payable _toUser, uint _amount) public returns (bool) {
require(msg.sender == ownerWallet, "Only Owner Wallet");
require(_toUser != address(0), "Invalid Address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
return true;
}
function userInvestInfo(uint _userID, uint _investID) public view returns(uint _invetAmount, uint _investTime, uint _investType){
return(userInvestments[_userID].investInfo[_investID].investAmount,userInvestments[_userID].investInfo[_investID].time,userInvestments[_userID].investInfo[_investID].flag);
}
function viewUserReferral(uint _userID) public view returns(uint[] memory) {
return users[_userID].referrals;
}
function findFreeReferrer(uint _userID) public view returns(uint) {
if(users[_userID].referrals.length < REFERRER_1_LEVEL_LIMIT) return _userID;
uint[] memory referrals = new uint[](126);
referrals[0] = users[_userID].referrals[0];
referrals[1] = users[_userID].referrals[1];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 126; i++) {
if(users[referrals[i]].referrals.length == REFERRER_1_LEVEL_LIMIT) {
if(i < 62) {
referrals[(i+1)*2] = users[referrals[i]].referrals[0];
referrals[(i+1)*2+1] = users[referrals[i]].referrals[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
// Referral Bounus
function directBonus(uint _ref, uint _usrID) internal{
if(((block.timestamp.sub(dailyPayoutTime[_ref])).div(1 days)) >= 1){
dailyPayout[_ref] = 0;
dailyPayoutTime[_ref] = now;
}
if(users[_ref].blocked == 2) return;
if(users[_ref].expiry < now) {
users[_ref].blocked = 2;
return;
}
uint directBonus_5_percentage = userInvestments[_usrID].initialInvestment*(5 trx)/(100 trx);
if(directBonus_5_percentage > 0){
address referrer = usersList[_ref];
require(address(uint160(referrer)).send(directBonus_5_percentage*(95 trx)/(100 trx)), "directBonus failed");
userInvestments[_ref].directBonusEarned += directBonus_5_percentage*(95 trx)/(100 trx);
users[_ref].totalEarned = users[_ref].totalEarned.add(directBonus_5_percentage*(95 trx)/(100 trx));
require(address(uint160(distributor)).send(directBonus_5_percentage*(5 trx)/(100 trx)));
// users[1].totalEarned = users[1].totalEarned.add(directBonus_5_percentage*(5 trx)/(100 trx));
emit directBonusEvent(usersList[_usrID], _usrID, referrer, users[_ref].id, directBonus_5_percentage*(95 trx)/(100 trx), now);
}
}
// binary payout
function binaryMapping(uint[] memory _userID, uint[] memory _binaryPayout) public {
require(lockStatus == 1,"Contract Locked");
require(msg.sender == distributor, "only distributor");
require(_userID.length == _binaryPayout.length,"invalid arguments length");
for(uint i=0;i<_userID.length;i++){
if(((block.timestamp.sub(dailyPayoutTime[_userID[i]])).div(1 days)) >= 1){
dailyPayout[_userID[i]] = 0;
dailyPayoutTime[_userID[i]] = now;
}
if(users[_userID[i]].blocked == 2) continue;
if(users[_userID[i]].expiry < now) {
users[_userID[i]].blocked = 2;
continue;
}
if((dailyPayout[_userID[i]]+_binaryPayout[i] > users[_userID[i]].celling) && (_userID[i] != 1))
_binaryPayout[i] = users[_userID[i]].celling - dailyPayout[_userID[i]];
if(_binaryPayout[i] > 0){
require(address(uint160(usersList[_userID[i]])).send((_binaryPayout[i].mul(95 trx).div(100 trx))),"Binary 95% transfer failed ");
require(address(uint160(distributor)).send((_binaryPayout[i].mul(5 trx).div(100 trx))),"binary admin commission 5% transfer failed ");
userInvestments[_userID[i]].binaryEarned = userInvestments[_userID[i]].binaryEarned.add((_binaryPayout[i].mul(95 trx).div(100 trx)));
users[_userID[i]].totalEarned = users[_userID[i]].totalEarned.add((_binaryPayout[i].mul(95 trx).div(100 trx)));
dailyPayout[_userID[i]] = dailyPayout[_userID[i]].add((_binaryPayout[i].mul(95 trx).div(100 trx)));
// users[1].totalEarned = users[1].totalEarned.add((_binaryPayout.mul(5 trx).div(100 trx)));
if((userInvestments[_userID[i]].binaryEarned >= rewardValue) && (users[_userID[i]].created >= now) && (users[_userID[i]].rewardStatus == 0)){
uint _reward = rewardValue.mul(5 trx).div(100 trx);
require(address(uint160(usersList[_userID[i]])).send(_reward.mul(95 trx).div(100 trx)),"reward transfer failed");
users[_userID[i]].totalEarned = users[_userID[i]].totalEarned.add(_reward.mul(95 trx).div(100 trx));
require(address(uint160(distributor)).send((_reward.mul(5 trx).div(100 trx))),"reward admin commission 5% transfer failed ");
// users[1].totalEarned = users[1].totalEarned.add((_reward.mul(5 trx).div(100 trx)));
users[_userID[i]].rewardStatus = 1;
emit rewardEvent(usersList[_userID[i]], _userID[i], rewardValue.mul(95 trx).div(100 trx), now);
}
emit binaryCommissionEvent(usersList[_userID[i]], _userID[i], (_binaryPayout[i].mul(95 trx).div(100 trx)), now);
}
}
}
function ROIDistribution(uint[] memory _userID, uint[] memory _amount) public{ // ROI
require(lockStatus == 1,"Contract Locked");
require(msg.sender == distributor, "only distributor");
require(_userID.length == _amount.length,"invalid arguments length");
for(uint i=0;i<_userID.length;i++){
if(users[_userID[i]].blocked == 2) continue;
if(users[_userID[i]].expiry < now) {
users[_userID[i]].blocked = 2;
continue;
}
if(_amount[i] > 0){
require(address(uint160(usersList[_userID[i]])).send(_amount[i].mul(95 trx).div(100 trx)), "ROI 95% transfer failed");
require(address(uint160(distributor)).send((_amount[i].mul(5 trx).div(100 trx))),"ROI admin commission 5% transfer failed ");
userInvestments[_userID[i]].ROIEarned = userInvestments[_userID[i]].ROIEarned.add(_amount[i].mul(95 trx).div(100 trx));
users[_userID[i]].totalEarned = users[_userID[i]].totalEarned.add(_amount[i].mul(95 trx).div(100 trx));
// users[1].totalEarned = users[1].totalEarned.add((_amount.mul(5 trx).div(100 trx)));
emit ROIEvent(usersList[_userID[i]], _userID[i], _amount[i].mul(95 trx).div(100 trx), now);
}
}
}
}
| 296,410 | 11,907 |
06a48994b96d34b48f114b068554c5977247aa4ecf4c208932445231257418c0
| 16,908 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x219fa49440c6c7d9f21c0f2c87d638b35382ab5a.sol
| 4,438 | 16,243 |
pragma solidity ^0.4.23;
library SafeMathLib {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * 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 DateTimeLib {
struct _DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) internal pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) internal pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) internal pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
dt.hour = getHour(timestamp);
dt.minute = getMinute(timestamp);
dt.second = getSecond(timestamp);
dt.weekday = getWeekday(timestamp);
}
function getYear(uint timestamp) internal pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) internal pure returns (uint8) {
return uint8(timestamp % 60);
}
function getWeekday(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
function toTimestamp(uint16 year, uint8 month, uint8 day) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) internal pure returns (uint timestamp) {
uint16 i;
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
timestamp += DAY_IN_SECONDS * (day - 1);
timestamp += HOUR_IN_SECONDS * (hour);
timestamp += MINUTE_IN_SECONDS * (minute);
timestamp += second;
return timestamp;
}
}
interface IERC20 {
function totalSupply() external constant returns (uint256);
function balanceOf(address _owner) external constant 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 constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address _spender, uint256 _value);
}
contract StandardToken is IERC20,DateTimeLib {
using SafeMathLib for uint256;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
string public constant symbol = "APB";
string public constant name = "AmpereX Bank";
uint _totalSupply = 10000000000 * 10 ** 6;
uint8 public constant decimals = 6;
function totalSupply() external constant returns (uint256) {
return _totalSupply;
}
function balanceOf(address _owner) external constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) {
require(_value > 0 && balances[_from] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value > 0 && allowed[_from][msg.sender] >= _value && 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 success) {
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];
}
}
contract LockableToken is StandardToken {
address internal developerReservedAddress = 0x80a1B223b944A86e517349CBB414965bC501d104;
uint[8] internal developerReservedUnlockTimes;
uint256[8] internal developerReservedBalanceLimits;
function getDeveloperReservedBalanceLimit() internal returns (uint256 balanceLimit) {
uint time = now;
for (uint index = 0; index < developerReservedUnlockTimes.length; index++) {
if (developerReservedUnlockTimes[index] == 0x0) {
continue;
}
if (time > developerReservedUnlockTimes[index]) {
developerReservedUnlockTimes[index] = 0x0;
} else {
return developerReservedBalanceLimits[index];
}
}
return 0;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) {
require(_from != 0x0 && _to != 0x0 && _value > 0x0);
if (_from == developerReservedAddress) {
uint256 balanceLimit = getDeveloperReservedBalanceLimit();
require(balances[_from].sub(balanceLimit) >= _value);
}
return super.transferInternal(_from, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != 0x0 && _to != 0x0 && _value > 0x0);
if (_from == developerReservedAddress) {
uint256 balanceLimit = getDeveloperReservedBalanceLimit();
require(balances[_from].sub(balanceLimit) >= _value);
}
return super.transferFrom(_from, _to, _value);
}
event UnlockTimeChanged(uint index, uint unlockTime, uint newUnlockTime);
event LockInfo(address indexed publicOfferingAddress, uint index, uint unlockTime, uint256 balanceLimit);
}
contract TradeableToken is LockableToken {
address internal publicOfferingAddress = 0xdC23333Acb4dAAd88fcF66D2807DB7c8eCDFa6dc;
uint256 public exchangeRate = 100000;
function buy(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != 0x0);
require(publicOfferingAddress != 0x0);
require(exchangeRate > 0x0);
require(_weiAmount > 0x0);
uint256 exchangeToken = _weiAmount.mul(exchangeRate);
exchangeToken = exchangeToken.div(1 * 10 ** 12);
publicOfferingAddress.transfer(_weiAmount);
super.transferInternal(publicOfferingAddress, _beneficiary, exchangeToken);
}
event ExchangeRateChanged(uint256 oldExchangeRate,uint256 newExchangeRate);
}
contract OwnableToken is TradeableToken {
address internal owner = 0x59923219FEC7dd1Bfc4C14076F4a216b90f3AEdC;
mapping(address => uint) administrators;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdministrator() {
require(msg.sender == owner || administrators[msg.sender] > 0x0);
_;
}
function transferOwnership(address _newOwner) onlyOwner public {
require(_newOwner != address(0));
owner = _newOwner;
emit OwnershipTransferred(owner, _newOwner);
}
function addAdministrator(address _adminAddress) onlyOwner public {
require(_adminAddress != address(0));
require(administrators[_adminAddress] <= 0x0);
administrators[_adminAddress] = 0x1;
emit AddAdministrator(_adminAddress);
}
function removeAdministrator(address _adminAddress) onlyOwner public {
require(_adminAddress != address(0));
require(administrators[_adminAddress] > 0x0);
administrators[_adminAddress] = 0x0;
emit RemoveAdministrator(_adminAddress);
}
function setExchangeRate(uint256 _exchangeRate) public onlyAdministrator returns (bool success) {
require(_exchangeRate > 0x0);
uint256 oldExchangeRate = exchangeRate;
exchangeRate = _exchangeRate;
emit ExchangeRateChanged(oldExchangeRate, exchangeRate);
return true;
}
function changeUnlockTime(uint _index, uint _unlockTime) public onlyAdministrator returns (bool success) {
require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _unlockTime > 0x0);
if(_index > 0x0) {
uint beforeUnlockTime = developerReservedUnlockTimes[_index - 1];
require(beforeUnlockTime == 0x0 || beforeUnlockTime < _unlockTime);
}
if(_index < developerReservedUnlockTimes.length - 1) {
uint afterUnlockTime = developerReservedUnlockTimes[_index + 1];
require(afterUnlockTime == 0x0 || _unlockTime < afterUnlockTime);
}
uint oldUnlockTime = developerReservedUnlockTimes[_index];
developerReservedUnlockTimes[_index] = _unlockTime;
emit UnlockTimeChanged(_index,oldUnlockTime,_unlockTime);
return true;
}
function getDeveloperReservedLockInfo(uint _index) public onlyAdministrator returns (uint, uint256) {
require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _index < developerReservedBalanceLimits.length);
emit LockInfo(developerReservedAddress,_index,developerReservedUnlockTimes[_index],developerReservedBalanceLimits[_index]);
return (developerReservedUnlockTimes[_index], developerReservedBalanceLimits[_index]);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdministrator(address indexed adminAddress);
event RemoveAdministrator(address indexed adminAddress);
}
contract APB is OwnableToken {
function APB() public {
balances[owner] = 5000000000 * 10 ** 6;
balances[publicOfferingAddress] = 3000000000 * 10 ** 6;
uint256 developerReservedBalance = 2000000000 * 10 ** 6;
balances[developerReservedAddress] = developerReservedBalance;
developerReservedUnlockTimes =
[
DateTimeLib.toTimestamp(2018, 6, 1),
DateTimeLib.toTimestamp(2018, 9, 1),
DateTimeLib.toTimestamp(2018, 12, 1),
DateTimeLib.toTimestamp(2019, 3, 1),
DateTimeLib.toTimestamp(2019, 6, 1),
DateTimeLib.toTimestamp(2019, 9, 1),
DateTimeLib.toTimestamp(2019, 12, 1),
DateTimeLib.toTimestamp(2020, 3, 1)
];
developerReservedBalanceLimits =
[
developerReservedBalance,
developerReservedBalance - (developerReservedBalance / 8) * 1,
developerReservedBalance - (developerReservedBalance / 8) * 2,
developerReservedBalance - (developerReservedBalance / 8) * 3,
developerReservedBalance - (developerReservedBalance / 8) * 4,
developerReservedBalance - (developerReservedBalance / 8) * 5,
developerReservedBalance - (developerReservedBalance / 8) * 6,
developerReservedBalance - (developerReservedBalance / 8) * 7
];
}
function() public payable {
buy(msg.sender, msg.value);
}
}
| 148,247 | 11,908 |
92c433f284662f050ae4b1b095b8aa79c3a548dad8e4c97bcb5d8d8762965ed7
| 13,020 |
.sol
|
Solidity
| false |
359775451
|
vntchain-bak/GGNNSmartVulDetector
|
d0317099a169bf0033a1f4bc43d1b5911e6ecb38
|
data/timestamp/solidity_contract/5580.sol
| 3,354 | 12,869 |
pragma solidity ^0.4.8;
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) constant public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
mapping (address => uint256) balances;
mapping (address => uint256) lockedBalances;
mapping (address => uint256) initLockedBalances;
mapping (address => mapping (address => uint256)) allowed;
bool allowTransfer = false;
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value && _value > 0 && allowTransfer) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 && allowTransfer) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant public returns (uint256 balance){
return balances[_owner] + lockedBalances[_owner];
}
function availableBalanceOf(address _owner) constant public returns (uint256 balance){
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining){
return allowed[_owner][_spender];
}
}
contract IMETOKEN is StandardToken, SafeMath {
string public constant name = "IME.IM Token";
string public constant symbol = "IME";
uint256 public constant decimals = 18;
string public version = "1.0";
address public etherProceedsAccount = 0x0;
address public multiWallet = 0x0;
mapping (address => bool) public isOwner;
address[] public owners;
bool public isFinalized;
uint256 public window0TotalSupply = 0;
uint256 public window1TotalSupply = 0;
uint256 public window2TotalSupply = 0;
uint256 public window3TotalSupply = 0;
uint256 public window0StartTime = 0;
uint256 public window0EndTime = 0;
uint256 public window1StartTime = 0;
uint256 public window1EndTime = 0;
uint256 public window2StartTime = 0;
uint256 public window2EndTime = 0;
uint256 public window3StartTime = 0;
uint256 public window3EndTime = 0;
uint256 public preservedTokens = 1300000000 * 10**decimals;
uint256 public window0TokenCreationCap = 200000000 * 10**decimals;
uint256 public window1TokenCreationCap = 200000000 * 10**decimals;
uint256 public window2TokenCreationCap = 300000000 * 10**decimals;
uint256 public window3TokenCreationCap = 0 * 10**decimals;
uint256 public window0TokenExchangeRate = 5000;
uint256 public window1TokenExchangeRate = 4000;
uint256 public window2TokenExchangeRate = 3000;
uint256 public window3TokenExchangeRate = 0;
uint256 public preICOLimit = 0;
bool public instantTransfer = false;
event CreateGameIco(address indexed _to, uint256 _value);
event PreICOTokenPushed(address indexed _buyer, uint256 _amount);
event UnlockBalance(address indexed _owner, uint256 _amount);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
function IMEIM() public
{
totalSupply = 2000000000 * 10**decimals;
isFinalized = false;
etherProceedsAccount = msg.sender;
}
function adjustTime(uint256 _window0StartTime, uint256 _window0EndTime,
uint256 _window1StartTime, uint256 _window1EndTime,
uint256 _window2StartTime, uint256 _window2EndTime)
public{
require(msg.sender == etherProceedsAccount);
window0StartTime = _window0StartTime;
window0EndTime = _window0EndTime;
window1StartTime = _window1StartTime;
window1EndTime = _window1EndTime;
window2StartTime = _window2StartTime;
window2EndTime = _window2EndTime;
}
function adjustSupply(uint256 _window0TotalSupply,
uint256 _window1TotalSupply,
uint256 _window2TotalSupply)
public{
require(msg.sender == etherProceedsAccount);
window0TotalSupply = _window0TotalSupply * 10**decimals;
window1TotalSupply = _window1TotalSupply * 10**decimals;
window2TotalSupply = _window2TotalSupply * 10**decimals;
}
function adjustCap(uint256 _preservedTokens,
uint256 _window0TokenCreationCap,
uint256 _window1TokenCreationCap,
uint256 _window2TokenCreationCap)
public{
require(msg.sender == etherProceedsAccount);
preservedTokens = _preservedTokens * 10**decimals;
window0TokenCreationCap = _window0TokenCreationCap * 10**decimals;
window1TokenCreationCap = _window1TokenCreationCap * 10**decimals;
window2TokenCreationCap = _window2TokenCreationCap * 10**decimals;
}
function adjustRate(uint256 _window0TokenExchangeRate,
uint256 _window1TokenExchangeRate,
uint256 _window2TokenExchangeRate)
public{
require(msg.sender == etherProceedsAccount);
window0TokenExchangeRate = _window0TokenExchangeRate;
window1TokenExchangeRate = _window1TokenExchangeRate;
window2TokenExchangeRate = _window2TokenExchangeRate;
}
function setProceedsAccount(address _newEtherProceedsAccount)
public{
require(msg.sender == etherProceedsAccount);
etherProceedsAccount = _newEtherProceedsAccount;
}
function setMultiWallet(address _newWallet)
public{
require(msg.sender == etherProceedsAccount);
multiWallet = _newWallet;
}
function setPreICOLimit(uint256 _preICOLimit)
public{
require(msg.sender == etherProceedsAccount);
preICOLimit = _preICOLimit;
}
function setInstantTransfer(bool _instantTransfer)
public{
require(msg.sender == etherProceedsAccount);
instantTransfer = _instantTransfer;
}
function setAllowTransfer(bool _allowTransfer)
public{
require(msg.sender == etherProceedsAccount);
allowTransfer = _allowTransfer;
}
function addOwner(address owner)
public{
require(msg.sender == etherProceedsAccount);
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
function removeOwner(address owner)
public{
require(msg.sender == etherProceedsAccount);
isOwner[owner] = false;
OwnerRemoval(owner);
}
function preICOPush(address buyer, uint256 amount)
public{
require(msg.sender == etherProceedsAccount);
uint256 tokens = 0;
uint256 checkedSupply = 0;
checkedSupply = safeAdd(window0TotalSupply, amount);
require(window0TokenCreationCap >= checkedSupply);
assignLockedBalance(buyer, amount);
window0TotalSupply = checkedSupply;
PreICOTokenPushed(buyer, amount);
}
function lockedBalanceOf(address _owner) constant public returns (uint256 balance) {
return lockedBalances[_owner];
}
function initLockedBalanceOf(address _owner) constant public returns (uint256 balance) {
return initLockedBalances[_owner];
}
function unlockBalance(address _owner, uint256 prob)
public
ownerExists(msg.sender)
returns (bool){
uint256 shouldUnlockedBalance = 0;
shouldUnlockedBalance = initLockedBalances[_owner] * prob / 100;
if(shouldUnlockedBalance > lockedBalances[_owner]){
shouldUnlockedBalance = lockedBalances[_owner];
}
balances[_owner] += shouldUnlockedBalance;
lockedBalances[_owner] -= shouldUnlockedBalance;
UnlockBalance(_owner, shouldUnlockedBalance);
return true;
}
function () payable public{
create();
}
function create() internal{
require(!isFinalized);
require(msg.value >= 0.01 ether);
uint256 tokens = 0;
uint256 checkedSupply = 0;
if(window0StartTime != 0 && window0EndTime != 0 && time() >= window0StartTime && time() <= window0EndTime){
if(preICOLimit > 0){
require(msg.value >= preICOLimit);
}
tokens = safeMult(msg.value, window0TokenExchangeRate);
checkedSupply = safeAdd(window0TotalSupply, tokens);
require(window0TokenCreationCap >= checkedSupply);
assignLockedBalance(msg.sender, tokens);
window0TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else if(window1StartTime != 0 && window1EndTime!= 0 && time() >= window1StartTime && time() <= window1EndTime){
tokens = safeMult(msg.value, window1TokenExchangeRate);
checkedSupply = safeAdd(window1TotalSupply, tokens);
require(window1TokenCreationCap >= checkedSupply);
balances[msg.sender] += tokens;
window1TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else if(window2StartTime != 0 && window2EndTime != 0 && time() >= window2StartTime && time() <= window2EndTime){
tokens = safeMult(msg.value, window2TokenExchangeRate);
checkedSupply = safeAdd(window2TotalSupply, tokens);
require(window2TokenCreationCap >= checkedSupply);
balances[msg.sender] += tokens;
window2TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else{
require(false);
}
}
function time() internal returns (uint) {
return block.timestamp;
}
function today(uint startTime) internal returns (uint) {
return dayFor(time(), startTime);
}
function dayFor(uint timestamp, uint startTime) internal returns (uint) {
return timestamp < startTime ? 0 : safeSubtract(timestamp, startTime) / 24 hours + 1;
}
function withDraw(uint256 _value) public{
require(msg.sender == etherProceedsAccount);
if(multiWallet != 0x0){
multiWallet.transfer(_value);
}else{
etherProceedsAccount.transfer(_value);
}
}
function finalize() public{
require(!isFinalized);
require(msg.sender == etherProceedsAccount);
isFinalized = true;
if(multiWallet != 0x0){
assignLockedBalance(multiWallet, totalSupply- window0TotalSupply- window1TotalSupply - window2TotalSupply);
if(this.balance > 0) multiWallet.transfer(this.balance);
}else{
assignLockedBalance(etherProceedsAccount, totalSupply- window0TotalSupply- window1TotalSupply - window2TotalSupply);
if(this.balance > 0) etherProceedsAccount.transfer(this.balance);
}
}
function supply() constant public returns (uint256){
return window0TotalSupply + window1TotalSupply + window2TotalSupply;
}
function assignLockedBalance(address _owner, uint256 val) private{
initLockedBalances[_owner] += val;
lockedBalances[_owner] += val;
}
}
| 65,872 | 11,909 |
7c7724dd11ebe2a3097daefd88d4692032be2c53ec84a804853d6786138285f4
| 14,797 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xb1d809dbe0bd0208e57c20e55f5a0a7f617aecce.sol
| 3,652 | 14,548 |
pragma solidity ^0.8.0;
library EnumerableSet {
struct AddressSet {
address[] _values;
mapping (address => uint256) _indexes;
}
function add(AddressSet storage set, address value) internal returns (bool) {
if (!contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function remove(AddressSet storage set, address value) internal returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
address lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return set._indexes[value] != 0;
}
function length(AddressSet storage set) internal view returns (uint256) {
return set._values.length;
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function initialize() external {
require(_owner == address(0), "Already initialized");
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IBEP20 {
function mint(address to, uint256 amount) external;
function balanceOf(address account) external view returns (uint256);
}
interface IUniswapV2Pair {
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function token0() external view returns (address);
function token1() external view returns (address);
}
contract TokenVault {
address public owner;
address public reimbursementToken;
address public factory;
constructor(address _owner,address _token) {
owner = _owner;
reimbursementToken = _token;
factory = msg.sender;
}
function transferToken(address to, uint256 amount) external {
require(msg.sender == factory,"caller should be factory");
safeTransfer(reimbursementToken, to, amount);
}
function withdrawTokens(uint256 amount) external {
require(msg.sender == owner, "caller should be owner");
uint256 available = Reimbursement(factory).getAvailableTokens(address(this));
require(available >= amount, "not enough available tokens");
safeTransfer(reimbursementToken, msg.sender, amount);
}
function rescueTokens(address someToken) external {
require(msg.sender == owner, "caller should be owner");
require(someToken != reimbursementToken, "Only third-party token");
uint256 available = IBEP20(someToken).balanceOf(address(this));
safeTransfer(someToken, msg.sender, available);
}
function safeTransfer(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
}
contract Reimbursement is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
struct Stake {
uint256 startTime; // stake start at timestamp
uint256 amount; // staked tokens amount
}
struct Setting {
address token; // reimbursement token
bool isMintable; // token can be minted by this contract
address owner; // owner of reimbursement vault
uint64 period; // staking period in seconds (365 days)
uint32 reimbursementRatio; // the ratio of deposited amount to reimbursement amount (with 2 decimals)
IUniswapV2Pair swapPair; // uniswap compatible pair for token and native coin (ETH, BNB)
bool isReversOrder; // if `true` then `token1 = token` otherwise `token0 = token`
}
mapping(address => Setting) public settings; // vault address (licensee address) => setting
mapping(address => uint256) public totalReserved; // vault address (licensee address) => total amount used for reimbursement
mapping(address => mapping(address => uint256)) public balances; // vault address => user address => eligible reimbursement balance
mapping(address => mapping(address => Stake)) public staking; // vault address => user address => Stake
mapping(address => EnumerableSet.AddressSet) vaults; // user address => licensee address list that user mat get reimbursement
mapping(address => mapping(address => uint256)) licenseeFees; // vault => contract => fee (with 2 decimals). I.e. 30 means 0.3%
mapping(address => EnumerableSet.AddressSet) licenseeVaults; // licensee address => list of vaults
event StakeToken(address indexed vault, address indexed user, uint256 date, uint256 amount);
event UnstakeToken(address indexed vault, address indexed user, uint256 date, uint256 amount);
event SetLicenseeFee(address indexed vault, address indexed projectContract, uint256 fee);
event VaultCreated(address indexed vault, address indexed owner, address indexed token);
event SetVaultOwner(address indexed vault, address indexed oldOwner, address indexed newOwner);
function setLicenseeFee(address vault, address projectContract, uint256 fee) external {
require(settings[vault].owner == msg.sender, "Only vault owner");
licenseeFees[vault][projectContract] = fee;
emit SetLicenseeFee(vault, projectContract, fee);
}
function getLicenseeFee(address vault, address projectContract) external view returns(uint256 fee) {
return licenseeFees[vault][projectContract];
}
function getLicenseeVaults(address licensee) external view returns(address[] memory vault) {
return licenseeVaults[licensee]._values;
}
function getVaults(address user) external view returns(address[] memory vault) {
return vaults[user]._values;
}
function getVaultsLength(address user) external view returns(uint256) {
return vaults[user].length();
}
function getVault(address user, uint256 index) external view returns(address) {
return vaults[user].at(index);
}
function getVaultOwner(address vault) external view returns(address) {
return settings[vault].owner;
}
function setVaultOwner(address vault, address newOwner) external {
require(msg.sender == settings[vault].owner, "caller should be owner");
require(newOwner != address(0), "Wrong new owner address");
emit SetVaultOwner(vault, settings[vault].owner, newOwner);
settings[vault].owner = newOwner;
}
function getVaultsBalance(address user) external view returns(address[] memory vault, uint256[] memory balance) {
vault = vaults[user]._values;
balance = new uint256[](vault.length);
for (uint i = 0; i < vault.length; i++) {
balance[i] = balances[vault[i]][user];
}
}
function getAvailableTokens(address vault) public view returns(uint256 available) {
available = IBEP20(settings[vault].token).balanceOf(vault) - totalReserved[vault];
}
function withdrawTokens(address vault, uint256 amount) external {
require(msg.sender == settings[vault].owner, "caller should be owner");
uint256 available = getAvailableTokens(vault);
require(available >= amount, "not enough available tokens");
TokenVault(vault).transferToken(msg.sender, amount);
}
function stake(address vault, uint256 amount) external {
uint256 balance = balances[vault][msg.sender];
require(balance != 0, "No tokens for reimbursement");
Stake storage s = staking[vault][msg.sender];
uint256 currentStake = s.amount;
safeTransferFrom(settings[vault].token, msg.sender, vault, amount);
totalReserved[vault] += amount;
if (currentStake != 0) {
uint256 interval = block.timestamp - s.startTime;
interval = interval * currentStake / (currentStake + amount);
s.startTime = block.timestamp - interval;
s.amount = currentStake + amount;
} else {
s.startTime = block.timestamp;
s.amount = amount;
}
emit StakeToken(vault, msg.sender, block.timestamp, amount);
}
function unstake(address vault) external {
Stake memory s = staking[vault][msg.sender];
Setting memory set = settings[vault];
uint256 amount;
uint256 balance = balances[vault][msg.sender];
if (set.period == 0) {
require(balance != 0, "No reimbursement");
amount = balance;
} else {
require(s.amount != 0, "No stake");
uint256 interval = block.timestamp - s.startTime;
amount = s.amount * 100 * interval / (set.period * set.reimbursementRatio);
}
delete staking[vault][msg.sender]; // remove staking record.
if (amount > balance) amount = balance;
balance -= amount;
balances[vault][msg.sender] = balance;
if (balance == 0) {
vaults[msg.sender].remove(vault); // remove vault from vaults list where user has reimbursement tokens
}
if (set.isMintable) {
totalReserved[vault] -= s.amount;
TokenVault(vault).transferToken(msg.sender, s.amount); // withdraw staked amount
IBEP20(set.token).mint(msg.sender, amount); // mint reimbursement token
amount += s.amount; // total amount: rewards + staking
} else {
amount += s.amount; // total amount: rewards + staking
totalReserved[vault] -= amount;
TokenVault(vault).transferToken(msg.sender, amount); // withdraw staked amount + rewards
}
emit UnstakeToken(vault, msg.sender, block.timestamp, amount);
}
function requestReimbursement(address user, uint256 feeAmount, address vault) external returns(address licenseeAddress){
uint256 licenseeFee = licenseeFees[vault][msg.sender];
if (licenseeFee == 0) return address(0); // project contract not added to reimbursement
Setting memory set = settings[vault];
(uint256 reserve0, uint256 reserve1,) = set.swapPair.getReserves();
if (set.isReversOrder) (reserve0, reserve1) = (reserve1, reserve0);
uint256 amount = reserve0 * feeAmount / reserve1;
if (!set.isMintable) {
uint256 reserve = totalReserved[vault];
uint256 available = IBEP20(set.token).balanceOf(vault) - reserve;
if (available < amount) return address(0); // not enough reimbursement tokens
totalReserved[vault] = reserve + amount;
}
uint256 balance = balances[vault][user];
if (balance == 0) vaults[user].add(vault);
balances[vault][user] = balance + amount;
return set.owner;
}
function newVault(address token, // reimbursement token
bool isMintable, // token can be minted by this contract
uint64 period, // staking period in seconds (365 days)
uint32 reimbursementRatio, // the ratio of deposited amount to reimbursement amount (with 2 decimals).
address swapPair, // uniswap compatible pair for token and native coin (ETH, BNB)
uint32[] memory licenseeFee, // percentage of Licensee fee (with 2 decimals). I.e. 30 means 0.3%
address[] memory projectContract // contract that has right to request reimbursement)
external
returns(address vault)
{
if (isMintable) {
require(msg.sender == owner(), "Only owner may add mintable token");
}
bool isReversOrder;
if (IUniswapV2Pair(swapPair).token1() == token) {
isReversOrder == true;
} else {
require(IUniswapV2Pair(swapPair).token0() == token, "Wrong swap pair");
}
vault = address(new TokenVault(msg.sender, token));
licenseeVaults[msg.sender].add(vault);
settings[vault] = Setting(token, isMintable, msg.sender, period, reimbursementRatio, IUniswapV2Pair(swapPair), isReversOrder);
require(licenseeFee.length == projectContract.length, "Wrong length");
for (uint i = 0; i < projectContract.length; i++) {
require(licenseeFee[i] <= 10000, "Wrong fee");
licenseeFees[vault][projectContract[i]] = licenseeFee[i];
emit SetLicenseeFee(vault, projectContract[i], licenseeFee[i]);
}
emit VaultCreated(vault, msg.sender, token);
}
function rescueTokens(address someToken) external onlyOwner {
uint256 available = IBEP20(someToken).balanceOf(address(this));
safeTransfer(someToken, msg.sender, available);
}
function safeTransfer(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
}
| 276,683 | 11,910 |
39563d7a6d4ac4ad8498f6de1d18f2f0e695445064597f63bd99a49b81eea26b
| 16,741 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x9ed4b0a2b8345eeb1e43a4d0298e351fc320d278.sol
| 4,096 | 16,358 |
pragma solidity ^0.8.0;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
interface IERC20Upgradeable {
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 IPureFiFarming{
function depositTo(uint16 _pid, uint256 _amount, address _beneficiary) external;
function deposit(uint16 _pid, uint256 _amount) external;
function withdraw(uint16 _pid, uint256 _amount) external;
function claimReward(uint16 _pid) external;
function exit(uint16 _pid) external;
function emergencyWithdraw(uint16 _pid) external;
function getContractData() external view returns (uint256, uint256, uint64);
function getPoolLength() external view returns (uint256);
function getPool(uint16 _index) external view returns (address, uint256, uint64, uint64, uint64, uint256, uint256);
function getUserInfo(uint16 _pid, address _user) external view returns (uint256, uint256, uint256);
}
library AddressUpgradeable {
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 _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);
}
}
}
}
library SafeERC20Upgradeable {
using AddressUpgradeable for address;
function safeTransfer(IERC20Upgradeable token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20Upgradeable token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
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 {
_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);
}
uint256[49] private __gap;
}
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal initializer {
__Context_init_unchained();
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal initializer {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
abstract contract PureFiPaymentPlan is Initializable, OwnableUpgradeable, PausableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
struct Vesting{
uint8 paymentPlan; //payment plan ID
uint64 startDate; //payment plan initiation date. Can be 0 if PaymentPlan refers to exact unlock timestamps.
uint256 totalAmount; //total amount of tokens vested for a person
uint256 withdrawnAmount; //amount withdrawn by user
}
mapping (address => Vesting) internal vestedTokens;
IERC20Upgradeable public token;
uint256 public totalVestedAmount; // total amount of vested tokens under this contract control.
address public farmingContract;
uint8 public farmingContractPool;
event Withdrawal(address indexed who, uint256 amount);
event PaymentPlanAdded(uint256 index);
event TokensVested(address indexed beneficiary, uint8 paymentPlan, uint64 startDate, uint256 amount);
function initialize(address _token) public initializer {
__Ownable_init();
__Pausable_init_unchained();
require(_token != address(0),"incorrect token address");
token = IERC20Upgradeable(_token);
}
function pause() onlyOwner public {
super._pause();
}
function unpause() onlyOwner public {
super._unpause();
}
function setFarmingContract(address _farmingContract, uint8 _farmingContractPool) onlyOwner public {
farmingContract = _farmingContract;
farmingContractPool = _farmingContractPool;
}
function vestTokens(uint8 _paymentPlan, uint64 _startDate, uint256 _amount, address _beneficiary) public onlyOwner whenNotPaused{
require(vestedTokens[_beneficiary].totalAmount == 0, "This address already has vested tokens");
require(_isPaymentPlanExists(_paymentPlan), "Incorrect payment plan index");
require(_amount > 0, "Can't vest 0 tokens");
require(token.balanceOf(address(this)) >= totalVestedAmount + _amount, "Not enough tokens for this vesting plan");
vestedTokens[_beneficiary] = Vesting(_paymentPlan, _startDate, _amount, 0);
totalVestedAmount += _amount;
emit TokensVested(_beneficiary, _paymentPlan, _startDate, _amount);
}
function withdrawAvailableTokens() public whenNotPaused {
(, uint256 available) = withdrawableAmount(msg.sender);
_prepareWithdraw(available);
token.safeTransfer(msg.sender, available);
}
function withdrawAndStakeAvailableTokens() public whenNotPaused {
require(farmingContract != address(0),"Farming contract is not defined");
(, uint256 available) = withdrawableAmount(msg.sender);
_prepareWithdraw(available);
token.safeApprove(farmingContract, available);
IPureFiFarming(farmingContract).depositTo(farmingContractPool, available, msg.sender);
}
function withdraw(uint256 _amount) public whenNotPaused {
_prepareWithdraw(_amount);
token.safeTransfer(msg.sender, _amount);
}
function withdrawAndStake(uint256 _amount) public whenNotPaused{
require(farmingContract != address(0),"Farming contract is not defined");
_prepareWithdraw(_amount);
token.safeApprove(farmingContract, _amount);
IPureFiFarming(farmingContract).depositTo(farmingContractPool, _amount, msg.sender);
}
function _prepareWithdraw(uint256 _amount) private {
require(vestedTokens[msg.sender].totalAmount > 0,"No tokens vested for this address");
(, uint256 available) = withdrawableAmount(msg.sender);
require(_amount <= available, "Amount exeeded current withdrawable amount");
require(available > 0, "Nothing to withdraw");
vestedTokens[msg.sender].withdrawnAmount += _amount;
totalVestedAmount -= _amount;
emit Withdrawal(msg.sender, _amount);
}
function withdrawableAmount(address _beneficiary) public virtual view returns (uint64, uint256);
function vestingData(address _beneficiary) public view returns (uint8, uint64, uint64, uint256, uint256, uint256) {
(uint64 nextUnlockDate, uint256 available) = withdrawableAmount(_beneficiary);
return (vestedTokens[_beneficiary].paymentPlan, vestedTokens[_beneficiary].startDate, nextUnlockDate, vestedTokens[_beneficiary].totalAmount, vestedTokens[_beneficiary].withdrawnAmount, available);
}
function _isPaymentPlanExists(uint8 _id) internal virtual view returns (bool);
}
contract PureFiFixedDatePaymentPlan is PureFiPaymentPlan {
struct PaymentPlan{
uint64[] unlockDateShift; //timestamp shift of the unlock date; I.e. unlock date = unlockDateShift + startDate
uint16[] unlockPercent; //unlock percents multiplied by 100;
}
PaymentPlan[] internal paymentPlans;
uint256 public constant PERCENT_100 = 100_00; // 100% with extra denominator
function addPaymentPlan(uint64[] memory _ts, uint16[] memory _percents) public onlyOwner whenNotPaused{
require(_ts.length == _percents.length,"array length doesn't match");
uint16 totalPercent = 0;
uint16 prevPercent = 0;
uint64 prevDate = 0;
for(uint i = 0; i < _ts.length; i++){
require (prevPercent <= _percents[i], "Incorrect percent value");
require (prevDate <= _ts[i], "Incorrect unlock date value");
prevPercent = _percents[i];
prevDate = _ts[i];
totalPercent += _percents[i];
}
require(totalPercent == PERCENT_100, "Total percent is not 100%");
paymentPlans.push(PaymentPlan(_ts, _percents));
emit PaymentPlanAdded(paymentPlans.length - 1);
}
function withdrawableAmount(address _beneficiary) public override view returns (uint64, uint256) {
require(vestedTokens[_beneficiary].totalAmount > 0,"No tokens vested for this address");
uint16 percentLocked = 0;
uint64 paymentPlanStartDate = vestedTokens[_beneficiary].startDate;
uint256 index = paymentPlans[vestedTokens[_beneficiary].paymentPlan].unlockPercent.length;
uint64 nextUnlockDate = 0;
while (index > 0 && uint64(block.timestamp) < paymentPlanStartDate + paymentPlans[vestedTokens[_beneficiary].paymentPlan].unlockDateShift[index-1]) {
index--;
nextUnlockDate = paymentPlanStartDate + paymentPlans[vestedTokens[_beneficiary].paymentPlan].unlockDateShift[index];
percentLocked += paymentPlans[vestedTokens[_beneficiary].paymentPlan].unlockPercent[index];
}
uint256 amountLocked = vestedTokens[_beneficiary].totalAmount*percentLocked / PERCENT_100;
uint256 remaining = vestedTokens[_beneficiary].totalAmount - vestedTokens[_beneficiary].withdrawnAmount;
uint256 available = 0;
if (remaining > amountLocked){
available = remaining - amountLocked;
} else {
available = 0;
}
return (nextUnlockDate, available);
}
function paymentPlanLength(uint256 _paymentPlan) public view returns(uint256){
return paymentPlans[_paymentPlan].unlockPercent.length;
}
function paymentPlanData(uint256 _paymentPlan, uint256 _index) public view returns (uint64, uint16){
return (paymentPlans[_paymentPlan].unlockDateShift[_index], paymentPlans[_paymentPlan].unlockPercent[_index]);
}
function _isPaymentPlanExists(uint8 _id) internal override view returns (bool){
return (_id < paymentPlans.length);
}
}
| 275,923 | 11,911 |
00221a5663b209da184b5005990545ae8d15840ea5ca07901a18eebf845d1106
| 31,632 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/29/2900ea0deb95070ae8e01c63cfcfc5769ca67a70_IP.sol
| 4,667 | 17,904 |
pragma solidity ^0.7.6;
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() {
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 IP is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "ISLAND PARADISE";
string private _symbol = "IP";
uint8 private _decimals = 9;
uint256 public allowTradeAt;
constructor() {
_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 pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender],
"Excluded addresses cannot call this function");
(uint256 rAmount, , , ,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee)
public
view
returns (uint256)
{
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount, , , ,) = _getValues(tAmount);
return rAmount;
} else {
(, uint256 rTransferAmount, , ,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount)
public
view
returns (uint256)
{
require(rAmount <= _rTotal,
"Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner {
require(!_isExcluded[account], "Account is already excluded");
if (_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner,
address spender,
uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function enableFairLaunch() external onlyOwner {
require(msg.sender != address(0),
"ERC20: approve from the zero address");
allowTradeAt = block.timestamp;
}
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 (block.timestamp < allowTradeAt + 24 hours && amount >= 10**6 * 10**9) {
revert("You cannot transfer more than 1 billion now");
}
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender,
address recipient,
uint256 tAmount) private {
(uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender,
address recipient,
uint256 tAmount) private {
(uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender,
address recipient,
uint256 tAmount) private {
(uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender,
address recipient,
uint256 tAmount) private {
(uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount)
private
view
returns (uint256,
uint256,
uint256,
uint256,
uint256)
{
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount,
tFee,
currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount)
private
pure
returns (uint256, uint256)
{
uint256 tFee = tAmount.div(100).mul(6);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount,
uint256 tFee,
uint256 currentRate)
private
pure
returns (uint256,
uint256,
uint256)
{
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply ||
_tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 101,458 | 11,912 |
511ce63aa505da980f6084c84085b2bda6517a832216a6e985ffe73c4fe2ee69
| 24,950 |
.sol
|
Solidity
| false |
305531673
|
penguinparty-eth/penguinparty.eth-Deliverables
|
557487bf274912a3bb3ba2c78e80f36b29a13445
|
SolidityContracts/ghostfarm_pool.sol
| 3,116 | 11,889 |
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;
}
}
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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IAToken {
function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);
}
interface IDelegationToken {
function delegate(address delegatee) external;
}
interface IStakedAave {
function stake(address to, uint256 amount) external;
function redeem(address to, uint256 amount) external;
function cooldown() external;
function claimRewards(address to, uint256 amount) external;
function delegate(address delegatee) external;
}
interface ICreditDelegationToken {
event BorrowAllowanceDelegated(address indexed fromUser,
address indexed toUser,
address asset,
uint256 amount);
function approveDelegation(address delegatee, uint256 amount) external;
function borrowAllowance(address fromUser, address toUser) external view returns (uint256);
}
contract wrappedATOKEN is Context, IERC20, 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;
address public _atokenAddress;
address public _ghostvault;
address public _stkaaveAddress;
address public _feedest;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
IERC20 AAVEaddx;
IStakedAave STKAAVEaddx;
event Mint(address indexed sender, uint amount0);
event Burn(address indexed sender, uint amount0);
event Change(address indexed to,string func);
event CreditLine(address indexed to,uint256 amt);
event Rewards(uint256 amount);
function setFeeDest(address val) onlyOwner public returns(address){
_feedest = val;
emit Change(val,"feedest");
return val;
}
function setGhostVault(address val) onlyOwner public returns(address){
_ghostvault = val;
emit Change(val,"ghostvault");
return val;
}
function setATOKENAddress(address AAVEAddress) onlyOwner public returns(address) {
AAVEaddx = IERC20(AAVEAddress);
_atokenAddress = AAVEAddress;
emit Change(AAVEAddress,"AAVE");
return _atokenAddress;
}
function setSTKAAVEAddress(address STKAAVEAddress) onlyOwner public returns(address) {
STKAAVEaddx = IStakedAave(STKAAVEAddress);
_stkaaveAddress = STKAAVEAddress;
emit Change(STKAAVEAddress,"STKAAVE");
return _stkaaveAddress;
}
function createCreditLine(address debtToken, address borrower, uint256 amountInWei) onlyOwner public{
ICreditDelegationToken(debtToken).approveDelegation(borrower, amountInWei);
emit CreditLine(borrower,amountInWei);
}
function claimStakingRewards(uint256 amt) onlyOwner public{
uint256 fees = (amt*10)/5000;
uint256 receivable = amt-fees;
STKAAVEaddx.claimRewards(_feedest,fees);
STKAAVEaddx.claimRewards(_ghostvault,receivable);
emit Rewards(amt);
}
function wrap(uint256 amount) public returns (uint256) {
IERC20 aave;
aave = IERC20(_atokenAddress);
uint256 totalAave = aave.balanceOf(address(this));
// Gets the amount of Ghost Farm in existence
uint256 totalShares = totalSupply();
// If no Ghost Farm exists, mint it 1:1 to the amount put in
if (totalShares == 0 || totalAave == 0) {
_mint(msg.sender, amount);
}
else {
uint256 what = amount.mul(totalShares).div(totalAave);
uint256 fees = (what*10)/5000;
require(fees>1,"Fee:Unpayable");
uint256 receivable = what-fees;
_mint(msg.sender, receivable);
_mint(_feedest, fees);
emit Mint(msg.sender,receivable);
emit Mint(_feedest,fees);
}
require(aave.transferFrom(msg.sender, address(this), amount),"Not enough tokens!");
return amount;
}
function unwrap(uint256 amount) public {
IERC20 aave;
aave = IERC20(_atokenAddress);
uint256 totalAave = aave.balanceOf(address(this));
// Gets the amount of Ghost Farm in existence
uint256 totalShares = totalSupply();
// Calculates the amount of Aave the Ghost Farm is worth
uint256 what = amount.mul(totalShares).div(totalAave);
uint256 fees = (what*10)/5000;
require(fees>1,"Fee:Unpayable");
uint256 receivable = what-fees;
aave.transfer(msg.sender,receivable);
_burn(msg.sender, amount);
emit Burn(msg.sender,amount);
}
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 { }
}
| 245,629 | 11,913 |
7f2bde0bfceada13da5f41158f1f56858431a04741ba14597575a26acd2321df
| 15,600 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXVyyevD4zfgBbN8MiPxe1Deecjmr9AoD7_TRONBUDDY.sol
| 3,916 | 14,771 |
//SourceUnit: tron_buddy.sol
pragma solidity 0.5.10;
contract XGOLD {
function deposit(address sender, address referrer) public payable;
}
contract TRONBUDDY {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
mapping(uint8 => uint256) public running_vid;
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 14;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public vidToAddress;
uint public lastUserId = 2;
uint public lastvId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
mapping(uint8 => uint) public blevelPrice;
XGOLD public xGOLD;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public
{
levelPrice[1] = 18 trx;
levelPrice[2] = 30 trx;
levelPrice[3] = 40 trx;
levelPrice[4] = 50 trx;
levelPrice[5] = 60 trx;
levelPrice[6] = 70 trx;
levelPrice[7] = 80 trx;
levelPrice[8] = 90 trx;
levelPrice[9] = 100 trx;
levelPrice[10] = 51200 trx;
levelPrice[11] = 102400 trx;
levelPrice[12] = 204800 trx;
levelPrice[13] = 409600 trx;
levelPrice[14] = 819200 trx;
blevelPrice[1] = 12 trx;
blevelPrice[2] = 30 trx;
blevelPrice[3] = 40 trx;
blevelPrice[4] = 50 trx;
blevelPrice[5] = 60 trx;
blevelPrice[6] = 70 trx;
blevelPrice[7] = 80 trx;
blevelPrice[8] = 90 trx;
blevelPrice[9] = 100 trx;
blevelPrice[10] = 51200 trx;
blevelPrice[11] = 102400 trx;
blevelPrice[12] = 204800 trx;
blevelPrice[13] = 409600 trx;
blevelPrice[14] = 819200 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
vidToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
running_vid[i]=1;
}
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable
{
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function setXGold(address xGoldAddress) public
{
require(msg.sender == owner, "onlyOwner");
require(address(xGOLD) == address(0));
xGOLD = XGOLD(xGoldAddress);
}
function withdrawLostTRXFromBalance() public
{
require(msg.sender == owner, "onlyOwner");
msg.sender.transfer(address(this).balance);
}
function registrationExt(address referrerAddress) external payable
{
registration(msg.sender, referrerAddress);
}
//=================== Start Buy New Level ===============
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1)
{
require(msg.value == levelPrice[level], "invalid price");
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
}
else {
require(msg.value == blevelPrice[level], "invalid price");
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(level);
users[msg.sender].x6Matrix[level].currentReferrer = freeX6Referrer;
users[msg.sender].activeX6Levels[level] = true;
updateX3Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
//=================== End Buy New Level ===============
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
if (address(xGOLD) != address(0)) {
xGOLD.deposit(userAddress, referrerAddress);
require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost");
} else {
require(msg.value == levelPrice[currentStartingLevel]+blevelPrice[currentStartingLevel] , "invalid registration cost");
}
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
vidToAddress[lastvId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
lastvId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(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 < 2) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress)
{
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].referrals.length < 1)
{
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2);
//close matrix
users[referrerAddress].x6Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL && users[referrerAddress].x6Matrix[level].reinvestCount==2)
{
users[referrerAddress].x6Matrix[level].blocked = true;
}
//create new one by recursion
//check referrer active level
running_vid[level]=running_vid[level]+1;
address freeReferrerAddress = findFreeX6Referrer(level);
if (users[referrerAddress].x6Matrix[level].currentReferrer != freeReferrerAddress)
{
users[referrerAddress].x6Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address)
{
while (true)
{
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(uint8 level) public view returns(address)
{
uint256 id=running_vid[level];
return vidToAddress[id];
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool)
{
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool)
{
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint256)
{
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, bool, uint256)
{
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].referrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool)
{
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if(matrix==1)
{
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
else
{
if (!address(uint160(receiver)).send(blevelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
//41a4e7176790732f8a2a7593902d63748386923531
| 289,690 | 11,914 |
7f25c0a4fdca3b7a45be24a027d6b060f193927a94c2cfdd9e7583499b2408a5
| 14,391 |
.sol
|
Solidity
| false |
595519022
|
0xJCN/Mr-Steal-Yo-Crypto-CTF
|
1a43c69cc3c35697bec04d7155a972305b6873d2
|
contracts/game-assets/AssetHolder.sol
| 3,791 | 14,046 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/token/ERC1155/IERC1155.sol";
import "@openzeppelin/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import "@openzeppelin/utils/introspection/ERC165.sol";
import "@openzeppelin/utils/Address.sol";
import "@openzeppelin/utils/Context.sol";
/// @dev ERC1155 token representation for storing all game assets
/// @dev differs from base ERC1155 contract in that each user can only store
/// @dev a single unique NFT id per token ID, & transfers can only be made to
/// @dev users who do not already own an instance of that token ID
/// @dev NFT id is stored to allow for easy wrapping/unwrapping of assets
contract AssetHolder is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// mapping from token ID to account NFT id owned
// user can only own a single NFT id per token ID
mapping(uint256 => mapping(address => uint256)) private _idOwned;
// mapping of whether account owns an NFT id for a token ID
mapping(uint256 => mapping(address => bool)) private _ownsAny;
// mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// used as the URI for all token types by relying on ID substitution
string private _uri;
/// @dev set URI on initialization
constructor(string memory uri_) {
_setURI(uri_);
}
/// @dev See {IERC165-supportsInterface}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
/// @dev returns the same URI for *all* token types
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/// @dev returns the NFT id for a given user `owner` and token ID `id`
function getIdOwned(uint256 id, address owner) public view returns (uint256) {
return _idOwned[id][owner];
}
/// @dev returns balance of account for token ID
/// @dev balance for a token ID can only be 0 or 1
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 _ownsAny[id][account] == true ? 1 : 0;
}
/// @dev returns balance of accounts for given token IDs
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;
}
/// @dev set approval for all
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/// @dev return whether `operator` is approved for `account`
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/// @dev single transfer of an NFT id for a specific token ID
/// @dev `amount` must be 1, `data` is the NFT id to transfer
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 nor approved");
_safeTransferFrom(from, to, id, amount, data);
}
/// @dev batch transfer of a set of NFT ids for a set of token IDs
/// @dev `amounts` must be 1s, `data` is array of NFT ids to transfer
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 nor approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/// @dev transfers single NFT id from `from` to `to` for a select token type `id`
/// @dev transfers only allowed to accounts which don't already own same token type `id`
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");
require(amount == 1, "ERC1155: invalid transfer amount"); // ignored
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 nftId = abi.decode(data,(uint256));
require(_ownsAny[id][from], "ERC1155: user doesn't own token ID");
require(_idOwned[id][from] == nftId, "ERC1155: user doesn't own NFT id");
require(!_ownsAny[id][to], "ERC1155: receiver already has token");
_ownsAny[id][from] = false;
_ownsAny[id][to] = true;
_idOwned[id][to] = nftId;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/// @dev transfers batch of NFT ids from `from` to `to` for set of token type `ids`
/// @dev transfers only allowed to accounts which don't already own same token types `ids`
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);
uint256[] memory nftIds = abi.decode(data,(uint256[]));
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 nftId = nftIds[i];
require(amounts[i] == 1, "ERC1155: invalid transfer amount"); // ignored
require(_ownsAny[id][from], "ERC1155: user doesn't own token ID");
require(_idOwned[id][from] == nftId, "ERC1155: user doesn't own NFT id");
require(!_ownsAny[id][to], "ERC1155: receiver already has token");
_ownsAny[id][from] = false;
_ownsAny[id][to] = true;
_idOwned[id][to] = nftId;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/// @dev sets new URI for all token types
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/// @dev mints NFT id to `to` for token type `id`
/// @param data Stores NFT id to mint to `to`
function _mint(address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(amount == 1, "ERC1155: invalid transfer amount"); // ignored
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
uint256 nftId = abi.decode(data,(uint256));
require(!_ownsAny[id][to], "ERC1155: receiver already has token");
_ownsAny[id][to] = true;
_idOwned[id][to] = nftId;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
/// @dev mints batch of NFT ids to `to` for token types `ids`
/// @param data Stores NFT ids to mint to `to`
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);
uint256[] memory nftIds = abi.decode(data,(uint256[]));
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
require(amounts[i] == 1, "ERC1155: invalid transfer amount"); // ignored
require(!_ownsAny[id][to], "ERC1155: receiver already has token");
_ownsAny[id][to] = true;
_idOwned[id][to] = nftIds[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);
}
/// @dev destroys token type `id` from `from`
function _burn(address from,
uint256 id,
uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(amount == 1, "ERC1155: invalid transfer amount"); // ignored
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
require(_ownsAny[id][from], "ERC1155: user does not own token");
_ownsAny[id][from] = false;
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
/// @dev destroys token types `ids` from `from`
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];
require(amounts[i] == 1, "ERC1155: invalid transfer amount"); // ignored
require(_ownsAny[id][from], "ERC1155: user does not own token");
_ownsAny[id][from] = false;
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
/// @dev approves `operator` to operate on all of `owner` tokens
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);
}
/// @dev hook that is called before any token transfer
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
/// @dev hook that is called after any token transfer
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 IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.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 IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155Receiver.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;
}
}
| 235,231 | 11,915 |
44dd32e45cab6fcc48df22c215160c06910c285262bd406f38c04248a20735b8
| 30,158 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/c5/c51298dc7B96F4eCaeF7f7bA68803BB0E90eA229_OneNetAggregatorsUNI.sol
| 4,993 | 20,448 |
pragma solidity ^0.5.16;
// https://docs.synthetix.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.synthetix.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getSynth(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address);
}
// https://docs.synthetix.io/contracts/source/interfaces/isynth
interface ISynth {
// Views
function currencyKey() external view returns (bytes32);
function transferableSynths(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 Synthetix
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
// https://docs.synthetix.io/contracts/source/interfaces/iissuer
interface IIssuer {
// Views
function allNetworksDebtInfo()
external
view
returns (uint256 debt,
uint256 sharesSupply,
bool isStale);
function anySynthOrSNXRateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableSynthCount() external view returns (uint);
function availableSynths(uint index) external view returns (ISynth);
function canBurnSynths(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 maxIssuableSynths(address issuer) external view returns (uint maxIssuable);
function minimumStakeTime() external view returns (uint);
function remainingIssuableSynths(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function synths(bytes32 currencyKey) external view returns (ISynth);
function getSynths(bytes32[] calldata currencyKeys) external view returns (ISynth[] memory);
function synthsByAddress(address synthAddress) external view returns (bytes32);
function totalIssuedSynths(bytes32 currencyKey, bool excludeOtherCollateral) external view returns (uint);
function transferableSynthetixAndAnyRateIsInvalid(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 Synthetix
function addSynths(ISynth[] calldata synthsToAdd) external;
function issueSynths(address from, uint amount) external;
function issueSynthsOnBehalf(address issueFor,
address from,
uint amount) external;
function issueMaxSynths(address from) external;
function issueMaxSynthsOnBehalf(address issueFor, address from) external;
function burnSynths(address from, uint amount) external;
function burnSynthsOnBehalf(address burnForAddress,
address from,
uint amount) external;
function burnSynthsToTarget(address from) external;
function burnSynthsToTargetOnBehalf(address burnForAddress, address from) external;
function burnForRedemption(address deprecatedSynthProxy,
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 issueSynthsWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function burnSynthsWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
}
// Internal references
// https://docs.synthetix.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);
}
// Inheritance
// Internal references
// https://docs.synthetix.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 getSynth(bytes32 key) external view returns (address) {
IIssuer issuer = IIssuer(repository["Issuer"]);
require(address(issuer) != address(0), "Cannot find Issuer address");
return address(issuer.synths(key));
}
event AddressImported(bytes32 name, address destination);
}
interface IDebtCache {
// Views
function cachedDebt() external view returns (uint);
function cachedSynthDebt(bytes32 currencyKey) external view returns (uint);
function cacheTimestamp() external view returns (uint);
function cacheInvalid() external view returns (bool);
function cacheStale() external view returns (bool);
function isInitialized() external view returns (bool);
function currentSynthDebts(bytes32[] calldata currencyKeys)
external
view
returns (uint[] memory debtValues,
uint futuresDebt,
uint excludedDebt,
bool anyRateIsInvalid);
function cachedSynthDebts(bytes32[] calldata currencyKeys) external view returns (uint[] memory debtValues);
function totalNonSnxBackedDebt() external view returns (uint excludedDebt, bool isInvalid);
function currentDebt() external view returns (uint debt, bool anyRateIsInvalid);
function cacheInfo()
external
view
returns (uint debt,
uint timestamp,
bool isInvalid,
bool isStale);
function excludedIssuedDebts(bytes32[] calldata currencyKeys) external view returns (uint[] memory excludedDebts);
// Mutative functions
function updateCachedSynthDebts(bytes32[] calldata currencyKeys) external;
function updateCachedSynthDebtWithRate(bytes32 currencyKey, uint currencyRate) external;
function updateCachedSynthDebtsWithRates(bytes32[] calldata currencyKeys, uint[] calldata currencyRates) external;
function updateDebtCacheValidity(bool currentlyInvalid) external;
function purgeCachedSynthDebt(bytes32 currencyKey) external;
function takeDebtSnapshot() external;
function recordExcludedDebtChange(bytes32 currencyKey, int256 delta) external;
function updateCachedsUSDDebt(int amount) external;
function importExcludedIssuedDebts(IDebtCache prevDebtCache, IIssuer prevIssuer) external;
}
// https://docs.synthetix.io/contracts/source/interfaces/isynthetixdebtshare
interface ISynthetixDebtShare {
// Views
function currentPeriodId() external view returns (uint128);
function allowance(address account, address spender) external view returns (uint);
function balanceOf(address account) external view returns (uint);
function balanceOfOnPeriod(address account, uint periodId) external view returns (uint);
function totalSupply() external view returns (uint);
function sharePercent(address account) external view returns (uint);
function sharePercentOnPeriod(address account, uint periodId) external view returns (uint);
// Mutative functions
function takeSnapshot(uint128 id) external;
function mintShare(address account, uint256 amount) external;
function burnShare(address account, uint256 amount) external;
function approve(address, uint256) external pure returns (bool);
function transfer(address to, uint256 amount) external pure returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
function addAuthorizedBroker(address target) external;
function removeAuthorizedBroker(address target) external;
function addAuthorizedToSnapshot(address target) external;
function removeAuthorizedToSnapshot(address target) external;
}
//import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/AggregatorV2V3Interface.sol";
interface AggregatorV2V3Interface {
function latestRound() external view returns (uint256);
function decimals() external view returns (uint8);
function getAnswer(uint256 roundId) external view returns (int256);
function getTimestamp(uint256 roundId) external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Libraries
// https://docs.synthetix.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
//import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/AggregatorV2V3Interface.sol";
// aggregator which reports the data from the system itself
// useful for testing
contract BaseOneNetAggregator is Owned, AggregatorV2V3Interface {
using SafeDecimalMath for uint;
AddressResolver public resolver;
uint public overrideTimestamp;
constructor(AddressResolver _resolver) public Owned(msg.sender) {
resolver = _resolver;
}
function setOverrideTimestamp(uint timestamp) public onlyOwner {
overrideTimestamp = timestamp;
emit SetOverrideTimestamp(timestamp);
}
function latestRoundData()
external
view
returns (uint80,
int256,
uint256,
uint256,
uint80)
{
return getRoundData(uint80(latestRound()));
}
function latestRound() public view returns (uint256) {
return 1;
}
function decimals() external view returns (uint8) {
return 0;
}
function getAnswer(uint256 _roundId) external view returns (int256 answer) {
(, answer, , ,) = getRoundData(uint80(_roundId));
}
function getTimestamp(uint256 _roundId) external view returns (uint256 timestamp) {
(, , timestamp, ,) = getRoundData(uint80(_roundId));
}
function getRoundData(uint80)
public
view
returns (uint80,
int256,
uint256,
uint256,
uint80);
event SetOverrideTimestamp(uint timestamp);
}
contract OneNetAggregatorsUNI is BaseOneNetAggregator {
bytes32 public constant CONTRACT_NAME = "OneNetAggregatorsUNI";
constructor(AddressResolver _resolver) public BaseOneNetAggregator(_resolver) {}
function getRoundData(uint80)
public
view
returns (uint80,
int256,
uint256,
uint256,
uint80)
{
// Fixed price of $6.9263 as defined in SIP-293.
uint fixedPrice = 6926300000000000000;
uint dataTimestamp = now;
return (1, int256(fixedPrice), dataTimestamp, dataTimestamp, 1);
}
}
| 150,169 | 11,916 |
507c6e1ac798999c6236c7f3dc6c83c55e687d0ac3233c5a9d044baceffafd80
| 24,244 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/83/83f5377de6dB3ba019c8458CB7cb7b5497752BD5_GGE.sol
| 3,100 | 11,751 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract GGE is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000000000 * 10**9;
string private _symbol = "GGE";
string private _name = "gge";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function Deployer(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 128,330 | 11,917 |
e9ff00aae5aded6eaed64ae7b4b8247727b1e55b5016fe9fe8265d403a2eacb1
| 25,367 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b1/b1CE95694E02126BEeE66bD6614410cA27C00a5e_OlympusTreasury.sol
| 5,565 | 22,354 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {size := extcodesize(account)}
return size > 0;
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface IOHMERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract OlympusTreasury is Ownable {
using SafeMath for uint;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {RESERVEDEPOSITOR, RESERVESPENDER, RESERVETOKEN, RESERVEMANAGER, LIQUIDITYDEPOSITOR, LIQUIDITYTOKEN, LIQUIDITYMANAGER, DEBTOR, REWARDMANAGER, SOHM}
address public immutable OHM;
uint public immutable blocksNeededForQueue;
address[] public reserveTokens; // Push only, beware false-positives.
mapping(address => bool) public isReserveToken;
mapping(address => uint) public reserveTokenQueue; // Delays changes to mapping.
address[] public reserveDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveDepositor;
mapping(address => uint) public reserveDepositorQueue; // Delays changes to mapping.
address[] public reserveSpenders; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveSpender;
mapping(address => uint) public reserveSpenderQueue; // Delays changes to mapping.
address[] public liquidityTokens; // Push only, beware false-positives.
mapping(address => bool) public isLiquidityToken;
mapping(address => uint) public LiquidityTokenQueue; // Delays changes to mapping.
address[] public liquidityDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint) public LiquidityDepositorQueue; // Delays changes to mapping.
mapping(address => address) public bondCalculator; // bond calculator for liquidity token
address[] public reserveManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveManager;
mapping(address => uint) public ReserveManagerQueue; // Delays changes to mapping.
address[] public liquidityManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityManager;
mapping(address => uint) public LiquidityManagerQueue; // Delays changes to mapping.
address[] public debtors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isDebtor;
mapping(address => uint) public debtorQueue; // Delays changes to mapping.
mapping(address => uint) public debtorBalance;
address[] public rewardManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isRewardManager;
mapping(address => uint) public rewardManagerQueue; // Delays changes to mapping.
address public sOHM;
uint public sOHMQueue; // Delays change to sOHM address
uint public totalReserves; // Risk-free value of all assets
uint public totalDebt;
constructor (address _OHM,
address _MIM,
uint _blocksNeededForQueue) {
require(_OHM != address(0));
OHM = _OHM;
isReserveToken[_MIM] = true;
reserveTokens.push(_MIM);
// isLiquidityToken[_OHMDAI] = true;
// liquidityTokens.push(_OHMDAI);
blocksNeededForQueue = _blocksNeededForQueue;
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[_token] || isLiquidityToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[_token]) {
require(isReserveDepositor[msg.sender], "Not approved");
} else {
require(isLiquidityDepositor[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
// mint OHM needed and store amount of rewards for distribution
send_ = value.sub(_profit);
IERC20Mintable(OHM).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[_token], "Not accepted");
// Only reserves can be used for redemptions
require(isReserveSpender[msg.sender] == true, "Not approved");
uint value = valueOf(_token, _amount);
IOHMERC20(OHM).burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = IERC20(sOHM).balanceOf(msg.sender);
// Can only borrow against sOHM held
uint availableDebt = maximumDebt.sub(debtorBalance[msg.sender]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[msg.sender] = debtorBalance[msg.sender].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithOHM(uint _amount) external {
require(isDebtor[msg.sender], "Not approved");
IOHMERC20(OHM).burnFrom(msg.sender, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, OHM, _amount, _amount);
}
function manage(address _token, uint _amount) external {
if (isLiquidityToken[_token]) {
require(isLiquidityManager[msg.sender], "Not approved");
} else {
require(isReserveManager[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[msg.sender], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(OHM).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(IERC20(OHM).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager() {
uint reserves;
for (uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add(valueOf(reserveTokens[i], IERC20(reserveTokens[i]).balanceOf(address(this))));
}
for (uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add(valueOf(liquidityTokens[i], IERC20(liquidityTokens[i]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[_token]) {
// convert amount to match OHM decimals
value_ = _amount.mul(10 ** IERC20(OHM).decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[_token]) {
value_ = IBondCalculator(bondCalculator[_token]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyManager() returns (bool) {
require(_address != address(0));
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
reserveDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
reserveSpenderQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
reserveTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
ReserveManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
LiquidityDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
LiquidityTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
LiquidityManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.DEBTOR) {// 7
debtorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
rewardManagerQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = block.number.add(blocksNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing, address _address, address _calculator) external onlyManager() returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[_address] = 0;
if (!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[_address];
isReserveDepositor[_address] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[_address] = 0;
if (!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[_address];
isReserveSpender[_address] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[_address] = 0;
if (!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[_address];
isReserveToken[_address] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[_address] = 0;
if (!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[_address];
isReserveManager[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[_address] = 0;
if (!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[_address];
isLiquidityDepositor[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[_address] = 0;
if (!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[_address];
isLiquidityToken[_address] = result;
bondCalculator[_address] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[_address] = 0;
if (!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[_address];
isLiquidityManager[_address] = result;
} else if (_managing == MANAGING.DEBTOR) {// 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[_address] = 0;
if (!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[_address];
isDebtor[_address] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[_address] = 0;
if (!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[_address];
isRewardManager[_address] = result;
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = 0;
sOHM = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[_address]) {
require(queue_[_address] != 0, "Must queue");
require(queue_[_address] <= block.number, "Queue not expired");
return true;
}
return false;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for (uint i = 0; i < _list.length; i++) {
if (_list[i] == _token) {
return true;
}
}
return false;
}
}
| 82,618 | 11,918 |
2b4d0afe4ef44fae3c2a67193ee4525e09518f333a5cdf5d8f2b30e18e1d2ac6
| 25,046 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/62/627f5734Ef2F017b1804d5b05cBF4d8B21314319_SousChef.sol
| 3,693 | 13,728 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
interface 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 Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeBEP20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
'SafeBEP20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
// import "@nomiclabs/buidler/console.sol";
contract SousChef {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 rewardPending;
}
// Info of Pool
struct PoolInfo {
uint256 lastRewardBlock; // Last block number that Rewards distribution occurs.
uint256 accRewardPerShare; // Accumulated reward per share, times 1e12. See below.
}
// The SYRUP TOKEN!
IBEP20 public syrup;
// rewards created per block.
uint256 public rewardPerBlock;
// Info.
PoolInfo public poolInfo;
// Info of each user that stakes Syrup tokens.
mapping (address => UserInfo) public userInfo;
// addresses list
address[] public addressList;
// The block number when mining starts.
uint256 public startBlock;
// The block number when mining ends.
uint256 public bonusEndBlock;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(IBEP20 _syrup,
uint256 _rewardPerBlock,
uint256 _startBlock,
uint256 _endBlock) public {
syrup = _syrup;
rewardPerBlock = _rewardPerBlock;
startBlock = _startBlock;
bonusEndBlock = _endBlock;
// staking pool
poolInfo = PoolInfo({
lastRewardBlock: startBlock,
accRewardPerShare: 0
});
}
function addressLength() external view returns (uint256) {
return addressList.length;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) internal view returns (uint256) {
if (_to <= bonusEndBlock) {
return _to.sub(_from);
} else if (_from >= bonusEndBlock) {
return 0;
} else {
return bonusEndBlock.sub(_from);
}
}
// View function to see pending Tokens on frontend.
function pendingReward(address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo;
UserInfo storage user = userInfo[_user];
uint256 accRewardPerShare = pool.accRewardPerShare;
uint256 stakedSupply = syrup.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && stakedSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(rewardPerBlock);
accRewardPerShare = accRewardPerShare.add(tokenReward.mul(1e12).div(stakedSupply));
}
return user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt).add(user.rewardPending);
}
// Update reward variables of the given pool to be up-to-date.
function updatePool() public {
if (block.number <= poolInfo.lastRewardBlock) {
return;
}
uint256 syrupSupply = syrup.balanceOf(address(this));
if (syrupSupply == 0) {
poolInfo.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(poolInfo.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(rewardPerBlock);
poolInfo.accRewardPerShare = poolInfo.accRewardPerShare.add(tokenReward.mul(1e12).div(syrupSupply));
poolInfo.lastRewardBlock = block.number;
}
// Deposit Syrup tokens to SousChef for Reward allocation.
function deposit(uint256 _amount) public {
require (_amount > 0, 'amount 0');
UserInfo storage user = userInfo[msg.sender];
updatePool();
syrup.safeTransferFrom(address(msg.sender), address(this), _amount);
if (user.amount == 0 && user.rewardDebt == 0 && user.rewardPending ==0) {
addressList.push(address(msg.sender));
}
user.rewardPending = user.amount.mul(poolInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt).add(user.rewardPending);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(poolInfo.accRewardPerShare).div(1e12);
emit Deposit(msg.sender, _amount);
}
// Withdraw Syrup tokens from SousChef.
function withdraw(uint256 _amount) public {
require (_amount > 0, 'amount 0');
UserInfo storage user = userInfo[msg.sender];
require(user.amount >= _amount, "withdraw: not enough");
updatePool();
syrup.safeTransfer(address(msg.sender), _amount);
user.rewardPending = user.amount.mul(poolInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt).add(user.rewardPending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(poolInfo.accRewardPerShare).div(1e12);
emit Withdraw(msg.sender, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw() public {
UserInfo storage user = userInfo[msg.sender];
syrup.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
}
| 317,624 | 11,919 |
10d48e6bafc5794711d0e5916222069b7eefbaad93ea6a452a18827321b75a15
| 15,833 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x383670ae601bdc30f15eee3fab8b55abf997d097.sol
| 3,244 | 14,820 |
pragma solidity ^0.4.13;
contract ReentrancyHandlingContract {
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
}
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);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract PriorityPassInterface {
function getAccountLimit(address _accountAddress) public constant returns (uint);
function getAccountActivity(address _accountAddress) public constant returns (bool);
}
contract ERC20TokenInterface {
function totalSupply() public constant returns (uint256 _totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SeedCrowdsaleContract is ReentrancyHandlingContract, Owned {
struct ContributorData {
uint contributionAmount;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blocktime);
event PresaleUnlimitedStarted(uint blocktime);
event CrowdsaleEnded(uint blocktime);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blocktime);
event MaxCapReached(uint blocktime);
event ContributionMade(address indexed contributor, uint amount);
PriorityPassInterface priorityPassContract = PriorityPassInterface(0x0);
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
//
// Unnamed function that runs when eth is sent to the contract
// @payable
//
function() noReentrancy payable public {
require(msg.value != 0); // Throw if value is 0
require(crowdsaleState != state.crowdsaleEnded); // Check if crowdsale has ended
bool stateChanged = checkCrowdsaleState(); // Check blocks time and calibrate crowdsale state
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) { // Check if contributor is in priorityPass
processTransaction(msg.sender, msg.value); // Process transaction and issue tokens
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) { // Check if contributor is in priorityPass
processTransaction(msg.sender, msg.value); // Process transaction and issue tokens
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
}
//
// @internal checks crowdsale state and emits events it
// @returns boolean
//
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) { // Check if max cap is reached
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp); // Close the crowdsale
CrowdsaleEnded(block.timestamp); // Raise event
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) { // Check if we are in presale phase
if (crowdsaleState != state.priorityPass) { // Check if state needs to be changed
crowdsaleState = state.priorityPass; // Set new state
PresaleStarted(block.timestamp); // Raise event
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) { // Check if we are in presale unlimited phase
if (crowdsaleState != state.openedPriorityPass) { // Check if state needs to be changed
crowdsaleState = state.openedPriorityPass; // Set new state
PresaleUnlimitedStarted(block.timestamp); // Raise event
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {// Check if crowdsale is over
crowdsaleState = state.crowdsaleEnded; // Set new state
CrowdsaleEnded(block.timestamp); // Raise event
return true;
}
}
return false;
}
//
// @internal determines if return eth or throw according to changing state
// @param _stateChanged boolean message about state change
//
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
//
// Getter to calculate how much user can contribute
// @param _contributor address of the contributor
//
function calculateMaxContribution(address _contributor) constant public returns (uint maxContribution) {
uint maxContrib;
if (crowdsaleState == state.priorityPass) { // Check if we are in priority pass
maxContrib = priorityPassContract.getAccountLimit(_contributor) - contributorList[_contributor].contributionAmount;
if (maxContrib > (maxP1Cap - ethRaised)) { // Check if max contribution is more that max cap
maxContrib = maxP1Cap - ethRaised; // Alter max cap
}
} else {
maxContrib = maxCap - ethRaised; // Alter max cap
}
return maxContrib;
}
//
// Return if there is overflow of contributed eth
// @internal processes transactions
// @param _contributor address of an contributor
// @param _amount contributed amount
//
function processTransaction(address _contributor, uint _amount) internal {
uint maxContribution = calculateMaxContribution(_contributor); // Calculate max users contribution
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount) { // Check if max contribution is lower than _amount sent
contributionAmount = maxContribution; // Set that user contributes his maximum alowed contribution
returnAmount = _amount - maxContribution; // Calculate how much he must get back
}
if (ethRaised + contributionAmount >= minCap && minCap > ethRaised) {
MinCapReached(block.timestamp);
}
if (contributorList[_contributor].contributionAmount == 0) { // Check if contributor has already contributed
contributorList[_contributor].contributionAmount = contributionAmount; // Set their contribution
contributorIndexes[nextContributorIndex] = _contributor; // Set contributors index
nextContributorIndex++;
} else {
contributorList[_contributor].contributionAmount += contributionAmount; // Add contribution amount to existing contributor
}
ethRaised += contributionAmount; // Add to eth raised
ContributionMade(msg.sender, contributionAmount); // Raise event about contribution
if (returnAmount != 0) {
_contributor.transfer(returnAmount); // Return overflow of ether
}
}
//
// Recovers ERC20 tokens other than eth that are send to this address
// @owner refunds the erc20 tokens
// @param _tokenAddress address of the erc20 token
// @param _to address to where tokens should be send to
// @param _amount amount of tokens to refund
//
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
//
// withdrawEth when minimum cap is reached
// @owner sets contributions to withdraw
//
function withdrawEth() onlyOwner public {
require(this.balance != 0);
require(ethRaised >= minCap);
pendingEthWithdrawal = this.balance;
}
uint public pendingEthWithdrawal;
//
// pulls the funds that were set to send with calling of
// withdrawEth when minimum cap is reached
// @multisig pulls the contributions to self
//
function pullBalance() public {
require(msg.sender == multisigAddress);
require(pendingEthWithdrawal > 0);
multisigAddress.transfer(pendingEthWithdrawal);
pendingEthWithdrawal = 0;
}
//
// Owner can batch return contributors contributions(eth)
// @owner returns contributions
// @param _numberOfReturns number of returns to do in one transaction
//
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap); // Check if crowdsale has failed
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = contributorIndexes[nextContributorToClaim]; // Get next unclaimed participant
if (currentParticipantAddress == 0x0) {
return; // Check if all the participants were compensated
}
if (!hasClaimedEthWhenFail[currentParticipantAddress]) { // Check if participant has already claimed
contribution = contributorList[currentParticipantAddress].contributionAmount; // Get contribution of participant
hasClaimedEthWhenFail[currentParticipantAddress] = true; // Set that he has claimed
if (!currentParticipantAddress.send(contribution)) { // Refund eth
ErrorSendingETH(currentParticipantAddress, contribution); // If there is an issue raise event for manual recovery
}
}
nextContributorToClaim += 1; // Repeat
}
}
//
// If there were any issue with refund owner can withdraw eth at the end for manual recovery
// @owner withdraws remaining funds
//
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0); // Check if there are any eth to claim
require(block.timestamp > crowdsaleEndedTime); // Check if crowdsale is over
require(contributorIndexes[nextContributorToClaim] == 0x0); // Check if all the users were refunded
multisigAddress.transfer(this.balance); // Withdraw to multisig for manual processing
}
//
// Owner can set multisig address for crowdsale
// @owner sets an address where funds will go
// @param _newAddress
//
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
//
// Setter for the whitelist contract
// @owner sets address of whitelist contract
// @param address
//
function setPriorityPassContract(address _newAddress) onlyOwner public {
priorityPassContract = PriorityPassInterface(_newAddress);
}
//
// Getter for the whitelist contract
// @returns white list contract address
//
function priorityPassContractAddress() constant public returns (address) {
return address(priorityPassContract);
}
//
// Before crowdsale starts owner can calibrate time of crowdsale stages
// @owner sends new times for the sale
// @param _presaleStartTime timestamp for sale limited start
// @param _presaleUnlimitedStartTime timestamp for sale unlimited
// @param _crowdsaleEndedTime timestamp for ending sale
//
function setCrowdsaleTimes(uint _presaleStartTime, uint _presaleUnlimitedStartTime, uint _crowdsaleEndedTime) onlyOwner public {
require(crowdsaleState == state.pendingStart); // Check if crowdsale has started
require(_presaleStartTime != 0); // Check if any value is 0
require(_presaleStartTime < _presaleUnlimitedStartTime); // Check if presaleUnlimitedStartTime is set properly
require(_presaleUnlimitedStartTime != 0); // Check if any value is 0
require(_presaleUnlimitedStartTime < _crowdsaleEndedTime); // Check if crowdsaleEndedTime is set properly
require(_crowdsaleEndedTime != 0); // Check if any value is 0
presaleStartTime = _presaleStartTime;
presaleUnlimitedStartTime = _presaleUnlimitedStartTime;
crowdsaleEndedTime = _crowdsaleEndedTime;
}
}
contract MediaSifterSeedCrowdsale is SeedCrowdsaleContract {
function MediaSifterSeedCrowdsale() {
presaleStartTime = 1512032400;
presaleUnlimitedStartTime = 1512063000;
crowdsaleEndedTime = 1512140400;
minCap = 416 ether;
maxP1Cap = 802 ether;
maxCap = 891 ether;
}
}
| 141,004 | 11,920 |
06546a07c3fa3ce6fd3147cc7e7dde6cd6d2652be97d56afa17eba981e48f3cc
| 29,123 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xFB09C60F0444ea8dD25C1edE629b2AB42740786F/contract.sol
| 5,171 | 18,411 |
//
// MATSUGORO Binance Smart Chain BEP20 contract
//
// TG: https://t.me/MATSUGORO
// Platform: http://sampei.finance/
//
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 MGOROToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 37000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Matsugoro';
string private constant _symbol = 'MGORO';
uint256 private _taxFee = 600;
uint256 private _burnFee = 200;
uint private _max_tx_size = 37000000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 249,116 | 11,921 |
4e64ff14817a97cd2b5a2a413e8f28972c29d26d3014ce011f00d24258690e45
| 26,460 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cb/cbf061e00afca84fbe66b2aef8d0a02b152207cb_RatCoin.sol
| 4,601 | 16,924 |
// Leave RATs to kill the RATs
// LP tokens will be burned
// Frictionless Rewards transperently
// 6% Tax (3% Burn // 3% back to Holders)
// Initial liquidty burned
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
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 () {
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 RatCoin is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'RatCoin';
string private _symbol = 'RAT';
uint8 private _decimals = 9;
uint256 public allowTradeAt;
constructor () {
_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 pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function enableFairLaunch() external onlyOwner() {
require(msg.sender != address(0), "ERC20: approve from the zero address");
allowTradeAt = block.timestamp;
}
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 (block.timestamp < allowTradeAt + 24 hours && amount >= 10**6 * 10**9) {
revert("You cannot transfer more than 1 billion now"); }
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(6);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 73,813 | 11,922 |
e3fad2d3a320fa0f7efaf3f23fd8aba0656d1fd6b18861e4dd654ab92729285a
| 13,599 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xcc6cc2f648686af73d1efbe7f9b7e4ae3566652a.sol
| 4,014 | 13,048 |
pragma solidity ^0.4.19;
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 ETH10K {
using SafeMath for uint256;
uint8 private constant MAX_COLS = 64;
uint8 private constant MAX_ROWS = 160;
uint8 private Reserved_upRow = 8;
uint8 private Reserved_downRow = 39;
uint8 private max_merge_size = 2;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
bool private erc721Enabled = false;
bool private mergeEnabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256 private startingPrice = 0.001 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (address => string) private usernameOfAddress;
function ETH10K () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
modifier onlyMergeEnable(){
require(mergeEnabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function enableMerge (bool status) onlyAdmins() public {
mergeEnabled = status;
}
function setReserved(uint8 _up,uint8 _down) onlyAdmins() public{
Reserved_upRow = _up;
Reserved_downRow = _down;
}
function setMaxMerge(uint8 num)onlyAdmins() external{
max_merge_size = num;
}
function withdrawAll () onlyOwner() public {
require(this.balance > 0);
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
function requestMerge(uint256[] ids)onlyMergeEnable() external {
require(ids.length == 4);
require(ids[0]%(10**8)/(10**4)<max_merge_size);
require(ids[1]%(10**8)/(10**4)<max_merge_size);
require(ids[2]%(10**8)/(10**4)<max_merge_size);
require(ids[3]%(10**8)/(10**4)<max_merge_size);
require(ownerOfItem[ids[0]] == msg.sender);
require(ownerOfItem[ids[1]] == msg.sender);
require(ownerOfItem[ids[2]] == msg.sender);
require(ownerOfItem[ids[3]] == msg.sender);
require(ids[0]+ (10**12) == ids[1]);
require(ids[0]+ (10**8) == ids[2]);
require(ids[0]+ (10**8) + (10**12) == ids[3]);
uint256 newPrice = priceOfItem[ids[0]]+priceOfItem[ids[1]]+priceOfItem[ids[2]]+priceOfItem[ids[3]];
uint256 newId = ids[0] + ids[0]%(10**8);
listedItems.push(newId);
priceOfItem[newId] = newPrice;
ownerOfItem[newId] = msg.sender;
ownerOfItem[ids[0]] = address(0);
ownerOfItem[ids[1]] = address(0);
ownerOfItem[ids[2]] = address(0);
ownerOfItem[ids[3]] = address(0);
}
function checkIsOnSale(uint256 _ypos)public view returns(bool isOnSale){
if(_ypos<Reserved_upRow||_ypos>Reserved_downRow){
return false;
}else{
return true;
}
}
function generateId(uint256 _xpos,uint256 _ypos,uint256 _size)internal pure returns(uint256 _id){
uint256 temp= _xpos * (10**12) + _ypos * (10**8) + _size*(10**4);
return temp;
}
function parseId(uint256 _id)internal pure returns(uint256 _x,uint256 _y,uint256 _size){
uint256 xpos = _id / (10**12);
uint256 ypos = (_id-xpos*(10**12)) / (10**8);
uint256 size = _id % (10**5) / (10**4);
return (xpos,ypos,size);
}
function setUserName(string _name)payable public{
require(msg.value >= 0.01 ether);
usernameOfAddress[msg.sender] = _name;
uint256 excess = msg.value - 0.01 ether;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
function getUserName()public view returns(string name){
return usernameOfAddress[msg.sender];
}
function getUserNameOf(address _user)public view returns(string name){
return usernameOfAddress[_user];
}
function addBlock(address _to, uint256 _xpos,uint256 _ypos,uint256 _size,uint256 _price) onlyAdmins() public {
require(checkIsOnSale(_ypos) == true);
require(_size == 1);
require(_xpos + _size <= MAX_COLS);
uint256 _itemId = generateId(_xpos,_ypos,_size);
require(priceOf(_itemId)==0);
require(ownerOf(_itemId)==address(0));
listedItems.push(_itemId);
priceOfItem[_itemId] = _price;
ownerOfItem[_itemId] = _to;
}
//Buy the block with somebody owned already
function buyOld (uint256 _index) payable public {
require(_index!=0);
require(msg.value >= priceOf(_index));
require(ownerOf(_index) != msg.sender);
require(ownerOf(_index) != address(0));
uint256 price = priceOf(_index);
address oldOwner = ownerOfItem[_index];
priceOfItem[_index] = calculateNextPrice(price);
uint256 excess = msg.value.sub(price);
address newOwner = msg.sender;
ownerOfItem[_index] = newOwner;
uint256 devCut = calculateDevCut(price);
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
//Buy a new block without anybody owned
function buyNew (uint256 _xpos,uint256 _ypos,uint256 _size) payable public {
require(checkIsOnSale(_ypos) == true);
require(_size == 1);
require(_xpos + _size <= MAX_COLS);
uint256 _itemId = generateId(_xpos,_ypos,_size);
require(priceOf(_itemId)==0);
require(ownerOf(_itemId)==address(0));
uint256 price =startingPrice;
address oldOwner = owner;
listedItems.push(_itemId);
priceOfItem[_itemId] = calculateNextPrice(price);
uint256 excess = msg.value.sub(price);
address newOwner = msg.sender;
ownerOfItem[_itemId] = newOwner;
uint256 devCut = calculateDevCut(price);
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function MergeStatus() public view returns (bool _MergeOpen) {
return mergeEnabled;
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "ETH10K.io";
}
function symbol() public pure returns (string _symbol) {
return "block";
}
function totalSupply() public view returns (uint256 _totalSupply) {
uint256 total = 0;
for(uint256 i=0; i<listedItems.length; i++){
if(ownerOf(listedItems[i])!=address(0)){
total++;
}
}
return total;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function cellsOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function getAllCellIds () public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](totalSupply());
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOfItem[listedItems[i]] != address(0)) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf () public view returns (uint256 _startingPrice) {
return startingPrice;
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice, uint256 _xpos, uint256 _ypos, uint256 _size) {
uint256 xpos;
uint256 ypos;
uint256 size;
(xpos,ypos,size) = parseId(_itemId);
return (ownerOfItem[_itemId],startingPriceOf(),priceOf(_itemId),nextPriceOf(_itemId),xpos,ypos,size);
}
function getAllCellInfo()external view returns(uint256[] _tokenIds,uint256[] _prices, address[] _owners){
uint256[] memory items = new uint256[](totalSupply());
uint256[] memory prices = new uint256[](totalSupply());
address[] memory owners = new address[](totalSupply());
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) !=address(0)) {
items[itemCounter] = listedItems[i];
prices[itemCounter] = priceOf(listedItems[i]);
owners[itemCounter] = ownerOf(listedItems[i]);
itemCounter += 1;
}
}
return (items,prices,owners);
}
function getAllCellInfoFrom_To(uint256 _from, uint256 _to)external view returns(uint256[] _tokenIds,uint256[] _prices, address[] _owners){
uint256 totalsize = totalSupply();
require(_from <= _to);
require(_to < totalsize);
uint256 size = _to-_from +1;
uint256[] memory items = new uint256[](size);
uint256[] memory prices = new uint256[](size);
address[] memory owners = new address[](size);
uint256 itemCounter = 0;
for (uint256 i = _from; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) !=address(0)) {
items[itemCounter] = listedItems[i];
prices[itemCounter] = priceOf(listedItems[i]);
owners[itemCounter] = ownerOf(listedItems[i]);
itemCounter += 1;
if(itemCounter > _to){
break;
}
}
}
return (items,prices,owners);
}
function getMaxMerge()external view returns(uint256 _maxMergeSize){
return max_merge_size;
}
function showBalance () onlyAdmins() public view returns (uint256 _ProfitBalance) {
return this.balance;
}
}
| 219,207 | 11,923 |
c5ded4ea1bb31777d1cedbbf722984f5a7c6203b4302ed32a60351abe57ce0a7
| 27,248 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/24/248e63a59d2eef7aa2ef36dc95c88971167d3468_MynosStaking.sol
| 4,172 | 16,558 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsMYNOS {
function rebase(uint256 MYNOSProfit_, 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 MynosStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable MYNOS;
address public immutable sMYNOS;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _MYNOS,
address _sMYNOS,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_MYNOS != address(0));
MYNOS = _MYNOS;
require(_sMYNOS != address(0));
sMYNOS = _sMYNOS;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(MYNOS).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(IsMYNOS(sMYNOS).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sMYNOS).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, IsMYNOS(sMYNOS).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsMYNOS(sMYNOS).balanceForGons(info.gons));
IERC20(MYNOS).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(sMYNOS).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(MYNOS).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsMYNOS(sMYNOS).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsMYNOS(sMYNOS).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsMYNOS(sMYNOS).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(MYNOS).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sMYNOS).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sMYNOS).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;
}
}
| 76,096 | 11,924 |
350614cf2839c5fe044079e313a567642ad8464ac060e037662dedee828fedb7
| 17,846 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb2819a0c3db0b9513a5ddd747f873877f622e083.sol
| 3,340 | 11,652 |
pragma solidity 0.4.20;
contract Ownable {
address public owner;
uint public totalSupply = 0;
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 Authorizable {
address[] authorizers;
mapping(address => uint256) authorizerIndex;
modifier onlyAuthorized {
require(isAuthorized(msg.sender));
_;
}
function Authorizable() public {
authorizers.length = 2;
authorizers[1] = msg.sender;
authorizerIndex[msg.sender] = 1;
}
function getAuthorizer(uint256 authIndex) external constant returns(address) {
return address(authorizers[authIndex + 1]);
}
function isAuthorized(address _addr) public constant returns(bool) {
return authorizerIndex[_addr] > 0;
}
function addAuthorized(address _addr) external onlyAuthorized {
authorizerIndex[_addr] = authorizers.length;
authorizers.length++;
authorizers[authorizers.length - 1] = _addr;
}
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
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;
}
//function assert(bool _assertion) internal pure {
// require (_assertion);
//}
}
contract ERC20Basic {
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 ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
// if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint value);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract RecToken is MintableToken {
string public standard = "Renta.City";
string public name = "Renta.City";
string public symbol = "REC";
uint public decimals = 18;
address public saleAgent;
bool public tradingStarted = false;
modifier hasStartedTrading() {
require(tradingStarted);
_;
}
function startTrading() public onlyOwner {
tradingStarted = true;
}
function transfer(address _to, uint _value) public hasStartedTrading {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public hasStartedTrading {
super.transferFrom(_from, _to, _value);
}
function set_saleAgent(address _value) public onlyOwner {
saleAgent = _value;
}
}
contract MainSale is Ownable, Authorizable {
using SafeMath for uint;
event TokenSold(address recipient, uint ether_amount, uint pay_amount, uint exchangerate);
event AuthorizedCreate(address recipient, uint pay_amount);
event MainSaleClosed();
RecToken public token = new RecToken();
address public multisigVault;
mapping(address => uint) public balances;
uint public hardcap = 100000 ether;
uint public altDeposits = 0;
uint public start = 1519862400;
uint public rate = 1000000000000000000000;
bool public isRefund = false;
uint public stage_Days = 30 days;
uint public stage_Discount = 0;
uint public commandPercent = 10;
uint public refererPercent = 2;
uint public bountyPercent = 2;
uint public maxBountyTokens = 0;
uint public maxTokensForCommand = 0;
uint public issuedBounty = 0; // <= 2% from total emission
uint public issuedTokensForCommand = 0; // <= 10% from total emission
modifier saleIsOn() {
require(now > start && now < start + stage_Days);
_;
}
modifier isUnderHardCap() {
require(multisigVault.balance + altDeposits <= hardcap);
_;
}
function bytesToAddress(bytes source) internal pure returns(address) {
uint result;
uint mul = 1;
for(uint i = 20; i > 0; i--) {
result += uint8(source[i-1])*mul;
mul = mul*256;
}
return address(result);
}
function set_stage_Days(uint _value) public onlyOwner {
stage_Days = _value * 1 days;
}
function set_stage_Discount(uint _value) public onlyOwner {
stage_Discount = _value;
}
function set_commandPercent(uint _value) public onlyOwner {
commandPercent = _value;
}
function set_refererPercent(uint _value) public onlyOwner {
refererPercent = _value;
}
function set_bountyPercent(uint _value) public onlyOwner {
bountyPercent = _value;
}
function set_Rate(uint _value) public onlyOwner {
rate = _value * 1 ether;
}
function createTokens(address recipient) public isUnderHardCap saleIsOn payable {
require(msg.value >= 0.01 ether);
// Calculate discounts
uint CurrentDiscount = 0;
if (now > start && now < (start + stage_Days)) {CurrentDiscount = stage_Discount;}
// Calculate tokens
uint tokens = rate.mul(msg.value).div(1 ether);
tokens = tokens + tokens.mul(CurrentDiscount).div(100);
token.mint(recipient, tokens);
balances[msg.sender] = balances[msg.sender].add(msg.value);
maxBountyTokens = token.totalSupply().mul(bountyPercent).div(100-bountyPercent).div(1 ether);
maxTokensForCommand = token.totalSupply().mul(commandPercent).div(100-commandPercent).div(1 ether);
require(multisigVault.send(msg.value));
TokenSold(recipient, msg.value, tokens, rate);
// Transfer 2% => to Referer
address referer = 0x0;
if(msg.data.length == 20) {
referer = bytesToAddress(bytes(msg.data));
require(referer != msg.sender);
uint refererTokens = tokens.mul(refererPercent).div(100);
if (referer != 0x0 && refererTokens > 0) {
token.mint(referer, refererTokens);
maxBountyTokens = token.totalSupply().mul(bountyPercent).div(100-bountyPercent).div(1 ether);
maxTokensForCommand = token.totalSupply().mul(commandPercent).div(100-commandPercent).div(1 ether);
TokenSold(referer, 0, refererTokens, rate);
}
}
}
function mintTokensForCommand(address recipient, uint tokens) public onlyOwner returns (bool){
maxTokensForCommand = token.totalSupply().mul(commandPercent).div(100-commandPercent).div(1 ether);
if (tokens <= (maxTokensForCommand - issuedTokensForCommand)) {
token.mint(recipient, tokens * 1 ether);
issuedTokensForCommand = issuedTokensForCommand + tokens;
maxTokensForCommand = token.totalSupply().mul(commandPercent).div(100-commandPercent).div(1 ether);
TokenSold(recipient, 0, tokens * 1 ether, rate);
return(true);
}
else {return(false);}
}
function mintBounty(address recipient, uint tokens) public onlyOwner returns (bool){
maxBountyTokens = token.totalSupply().mul(bountyPercent).div(100-bountyPercent).div(1 ether);
if (tokens <= (maxBountyTokens - issuedBounty)) {
token.mint(recipient, tokens * 1 ether);
issuedBounty = issuedBounty + tokens;
maxBountyTokens = token.totalSupply().mul(bountyPercent).div(100-bountyPercent).div(1 ether);
TokenSold(recipient, 0, tokens * 1 ether, rate);
return(true);
}
else {return(false);}
}
function refund() public {
require(isRefund);
uint value = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(value);
}
function startRefund() public onlyOwner {
isRefund = true;
}
function stopRefund() public onlyOwner {
isRefund = false;
}
function setAltDeposit(uint totalAltDeposits) public onlyOwner {
altDeposits = totalAltDeposits;
}
function setHardCap(uint _hardcap) public onlyOwner {
hardcap = _hardcap;
}
function setStart(uint _start) public onlyOwner {
start = _start;
}
function setMultisigVault(address _multisigVault) public onlyOwner {
if (_multisigVault != address(0)) {
multisigVault = _multisigVault;
}
}
function finishMinting() public onlyOwner {
uint issuedTokenSupply = token.totalSupply();
uint restrictedTokens = issuedTokenSupply.mul(commandPercent).div(100-commandPercent);
token.mint(multisigVault, restrictedTokens);
token.finishMinting();
token.transferOwnership(owner);
MainSaleClosed();
}
function retrieveTokens(address _token) public payable {
require(msg.sender == owner);
ERC20 erctoken = ERC20(_token);
erctoken.transfer(multisigVault, erctoken.balanceOf(this));
}
function() external payable {
createTokens(msg.sender);
}
}
| 199,825 | 11,925 |
2529014d2e73b8fafa626a1b6510d9211cb3d34135ee174d41af1431ecbaa34d
| 15,417 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x618bb37e5644da4946f052c50d7819f95d327c8b.sol
| 4,116 | 14,893 |
pragma solidity ^0.4.18;
contract BLAccess {
address public mainAddress; //Main Contract Address
event UpdatedMainAccount(address _newMainAddress);
function BLAccess() public {
mainAddress = msg.sender;
}
modifier onlyPrimary() {
require(msg.sender == mainAddress);
_;
}
//Allows to change the primary account for the contract
function setPrimaryAccount(address _newMainAddress) external onlyPrimary {
require(_newMainAddress != address(0));
mainAddress = _newMainAddress;
UpdatedMainAccount(_newMainAddress);
}
}
contract DataStorageInterface {
function getUInt(bytes32 record) public constant returns (uint);
function setUInt(bytes32 record, uint value) public;
function getAdd(bytes32 record) public constant returns (address);
function setAdd(bytes32 record, address value) public;
function getBytes32(bytes32 record) public constant returns (bytes32);
function setBytes32(bytes32 record, bytes32 value) public;
function getBool(bytes32 record) public constant returns (bool);
function setBool(bytes32 record, bool value) public;
function withdraw(address beneficiary) public;
}
contract BLStorage is BLAccess {
DataStorageInterface internal s;
address public storageAddress;
event StorageUpdated(address _newStorageAddress);
function BLStorage() public {
s = DataStorageInterface(mainAddress);
}
// allows to setup a new Storage address. Should never be needed but you never know!
function setDataStorage(address newAddress) public onlyPrimary {
s = DataStorageInterface(newAddress);
storageAddress = newAddress;
StorageUpdated(newAddress);
}
function getKey(uint x, uint y) internal pure returns(bytes32 key) {
key = keccak256(x, ":", y);
}
}
contract BLBalances is BLStorage {
event WithdrawBalance(address indexed owner, uint amount);
event AllowanceGranted(address indexed owner, uint _amount);
event SentFeeToPlatform(uint amount);
event SentAmountToOwner(uint amount, address indexed owner);
// get the balance for a given account
function getBalance() public view returns (uint) {
return s.getUInt(keccak256(msg.sender, "balance"));
}
// get the balance for a given account
function getAccountBalance(address _account) public view onlyPrimary returns (uint) {
return s.getUInt(keccak256(_account, "balance"));
}
function getAccountAllowance(address _account) public view onlyPrimary returns (uint) {
return s.getUInt(keccak256(_account, "promoAllowance"));
}
function getMyAllowance() public view returns (uint) {
return s.getUInt(keccak256(msg.sender, "promoAllowance"));
}
// allow a block allowance for promo and early beta users
function grantAllowance(address beneficiary, uint allowance) public onlyPrimary {
uint existingAllowance = s.getUInt(keccak256(beneficiary, "promoAllowance"));
existingAllowance += allowance;
s.setUInt(keccak256(beneficiary, "promoAllowance"), existingAllowance);
AllowanceGranted(beneficiary, allowance);
}
// withdraw the current balance
function withdraw() public {
uint balance = s.getUInt(keccak256(msg.sender, "balance"));
s.withdraw(msg.sender);
WithdrawBalance(msg.sender, balance);
}
// Trading and buying balances flow
function rewardParties (address owner, uint feePercentage) internal {
uint fee = msg.value * feePercentage / 100;
rewardContract(fee);
rewardPreviousOwner(owner, msg.value - fee);
}
// contract commissions
function rewardContract (uint fee) internal {
uint mainBalance = s.getUInt(keccak256(mainAddress, "balance"));
mainBalance += fee;
s.setUInt(keccak256(mainAddress, "balance"), mainBalance);
SentFeeToPlatform(fee);
}
// reward the previous owner of the block or the contract if the block is bought for the first time
function rewardPreviousOwner (address owner, uint amount) internal {
uint rewardBalance;
if (owner == address(0)) {
rewardBalance = s.getUInt(keccak256(mainAddress, "balance"));
rewardBalance += amount;
s.setUInt(keccak256(mainAddress, "balance"), rewardBalance);
SentAmountToOwner(amount, mainAddress);
} else {
rewardBalance = s.getUInt(keccak256(owner, "balance"));
rewardBalance += amount;
s.setUInt(keccak256(owner, "balance"), rewardBalance);
SentAmountToOwner(amount, owner);
}
}
}
contract BLBlocks is BLBalances {
event CreatedBlock(uint x,
uint y,
uint price,
address indexed owner,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL);
event SetBlockForSale(uint x,
uint y,
uint price,
address indexed owner);
event UnsetBlockForSale(uint x,
uint y,
address indexed owner);
event BoughtBlock(uint x,
uint y,
uint price,
address indexed owner,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL);
event SoldBlock(uint x,
uint y,
uint oldPrice,
uint newPrice,
uint feePercentage,
address indexed owner);
event UpdatedBlock(uint x,
uint y,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL,
address indexed owner);
// Create a block if it doesn't exist
function createBlock(uint x,
uint y,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL) public payable {
bytes32 key = getKey(x, y);
uint initialPrice = s.getUInt("initialPrice");
address owner = s.getAdd(keccak256(key, "owner"));
uint allowance = s.getUInt(keccak256(msg.sender, "promoAllowance"));
require(msg.value >= initialPrice || allowance > 0);
require(owner == address(0));
uint feePercentage = s.getUInt("buyOutFeePercentage");
if (msg.value >= initialPrice) {
rewardParties(owner, feePercentage);
s.setUInt(keccak256(key, "price"), msg.value);
} else {
allowance--;
s.setUInt(keccak256(msg.sender, "promoAllowance"), allowance);
s.setUInt(keccak256(key, "price"), initialPrice);
}
s.setBytes32(keccak256(key, "name"), name);
s.setBytes32(keccak256(key, "description"), description);
s.setBytes32(keccak256(key, "url"), url);
s.setBytes32(keccak256(key, "imageURL"), imageURL);
s.setAdd(keccak256(key, "owner"), msg.sender);
uint blockCount = s.getUInt("blockCount");
blockCount++;
s.setUInt("blockCount", blockCount);
storageAddress.transfer(msg.value);
CreatedBlock(x,
y,
msg.value,
msg.sender,
name,
description,
url,
imageURL);
}
// Get details for a block
function getBlock (uint x, uint y) public view returns (uint price,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL,
uint forSale,
uint pricePerDay,
address owner) {
bytes32 key = getKey(x, y);
price = s.getUInt(keccak256(key, "price"));
name = s.getBytes32(keccak256(key, "name"));
description = s.getBytes32(keccak256(key, "description"));
url = s.getBytes32(keccak256(key, "url"));
imageURL = s.getBytes32(keccak256(key, "imageURL"));
forSale = s.getUInt(keccak256(key, "forSale"));
pricePerDay = s.getUInt(keccak256(key, "pricePerDay"));
owner = s.getAdd(keccak256(key, "owner"));
}
// Sets a block up for sale
function sellBlock(uint x, uint y, uint price) public {
bytes32 key = getKey(x, y);
uint basePrice = s.getUInt(keccak256(key, "price"));
require(s.getAdd(keccak256(key, "owner")) == msg.sender);
require(price < basePrice * 2);
s.setUInt(keccak256(key, "forSale"), price);
SetBlockForSale(x, y, price, msg.sender);
}
// Sets a block not for sale
function cancelSellBlock(uint x, uint y) public {
bytes32 key = getKey(x, y);
require(s.getAdd(keccak256(key, "owner")) == msg.sender);
s.setUInt(keccak256(key, "forSale"), 0);
UnsetBlockForSale(x, y, msg.sender);
}
// transfers ownership of an existing block
function buyBlock(uint x,
uint y,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL) public payable {
bytes32 key = getKey(x, y);
uint price = s.getUInt(keccak256(key, "price"));
uint forSale = s.getUInt(keccak256(key, "forSale"));
address owner = s.getAdd(keccak256(key, "owner"));
require(owner != address(0));
require((forSale > 0 && msg.value >= forSale) || msg.value >= price * 2);
uint feePercentage = s.getUInt("buyOutFeePercentage");
rewardParties(owner, feePercentage);
s.setUInt(keccak256(key, "price"), msg.value);
s.setBytes32(keccak256(key, "name"), name);
s.setBytes32(keccak256(key, "description"), description);
s.setBytes32(keccak256(key, "url"), url);
s.setBytes32(keccak256(key, "imageURL"), imageURL);
s.setAdd(keccak256(key, "owner"), msg.sender);
s.setUInt(keccak256(key, "forSale"), 0);
s.setUInt(keccak256(key, "pricePerDay"), 0);
storageAddress.transfer(msg.value);
BoughtBlock(x, y, msg.value, msg.sender,
name, description, url, imageURL);
SoldBlock(x, y, price, msg.value, feePercentage, owner);
}
// update details for an existing block
function updateBlock(uint x,
uint y,
bytes32 name,
bytes32 description,
bytes32 url,
bytes32 imageURL) public {
bytes32 key = getKey(x, y);
address owner = s.getAdd(keccak256(key, "owner"));
require(msg.sender == owner);
s.setBytes32(keccak256(key, "name"), name);
s.setBytes32(keccak256(key, "description"), description);
s.setBytes32(keccak256(key, "url"), url);
s.setBytes32(keccak256(key, "imageURL"), imageURL);
UpdatedBlock(x, y, name, description, url, imageURL, msg.sender);
}
}
contract BLTenancies is BLBlocks {
event ToRent(uint x,
uint y,
uint pricePerDay,
address indexed owner);
event NotToRent(uint x,
uint y,
address indexed owner);
event LeasedBlock(uint x,
uint y,
uint paid,
uint expiry,
bytes32 tenantName,
bytes32 tenantDescription,
bytes32 teantURL,
bytes32 tenantImageURL,
address indexed owner);
event RentedBlock(uint x,
uint y,
uint paid,
uint feePercentage,
address indexed owner);
// Sets a block up for rent, requires a rental price to be provided
function setForRent(uint x,
uint y,
uint pricePerDay) public {
bytes32 key = getKey(x, y);
uint price = s.getUInt(keccak256(key, "price"));
require(s.getAdd(keccak256(key, "owner")) == msg.sender);
require(pricePerDay >= price / 10);
s.setUInt(keccak256(key, "pricePerDay"), pricePerDay);
ToRent(x, y, pricePerDay, msg.sender);
}
// Sets a block not for rent
function cancelRent(uint x,
uint y) public {
bytes32 key = getKey(x, y);
address owner = s.getAdd(keccak256(key, "owner"));
require(owner == msg.sender);
s.setUInt(keccak256(key, "pricePerDay"), 0);
NotToRent(x, y, msg.sender);
}
// actually rent a block to a willing tenant
function leaseBlock(uint x,
uint y,
uint duration,
bytes32 tenantName,
bytes32 tenantDescription,
bytes32 tenantURL,
bytes32 tenantImageURL) public payable {
bytes32 key = getKey(x, y);
uint pricePerDay = s.getUInt(keccak256(key, "pricePerDay"));
require(pricePerDay > 0);
require(msg.value >= pricePerDay * duration);
require(now >= s.getUInt(keccak256(key, "expiry")));
address owner = s.getAdd(keccak256(key, "owner"));
uint feePercentage = s.getUInt("buyOutFeePercentage");
rewardParties(owner, feePercentage);
uint expiry = now + 86400 * duration;
s.setUInt(keccak256(key, "expiry"), expiry);
s.setBytes32(keccak256(key, "tenantName"), tenantName);
s.setBytes32(keccak256(key, "tenantDescription"), tenantDescription);
s.setBytes32(keccak256(key, "tenantURL"), tenantURL);
s.setBytes32(keccak256(key, "tenantImageURL"), tenantImageURL);
storageAddress.transfer(msg.value);
RentedBlock(x, y, msg.value, feePercentage, owner);
LeasedBlock(x, y, msg.value, expiry, tenantName, tenantDescription, tenantURL, tenantImageURL, msg.sender);
}
// get details for a tenancy
function getTenancy (uint x, uint y) public view returns (uint expiry,
bytes32 tenantName,
bytes32 tenantDescription,
bytes32 tenantURL,
bytes32 tenantImageURL) {
bytes32 key = getKey(x, y);
expiry = s.getUInt(keccak256(key, "tenantExpiry"));
tenantName = s.getBytes32(keccak256(key, "tenantName"));
tenantDescription = s.getBytes32(keccak256(key, "tenantDescription"));
tenantURL = s.getBytes32(keccak256(key, "tenantURL"));
tenantImageURL = s.getBytes32(keccak256(key, "tenantImageURL"));
}
}
contract BLMain is BLTenancies {
event ChangedInitialPrice(uint price);
event ChangedFeePercentage(uint fee);
// provides the total number of purchased blocks
function totalSupply() public view returns (uint count) {
count = s.getUInt("blockCount");
return count;
}
// allows to change the price of an empty block
function setInitialPrice(uint price) public onlyPrimary {
s.setUInt("initialPrice", price);
ChangedInitialPrice(price);
}
// allows to change the platform fee percentage
function setFeePercentage(uint feePercentage) public onlyPrimary {
s.setUInt("buyOutFeePercentage", feePercentage);
ChangedFeePercentage(feePercentage);
}
// provides the starting price for an empty block
function getInitialPrice() public view returns (uint) {
return s.getUInt("initialPrice");
}
// provides the price of an empty block
function getFeePercentage() public view returns (uint) {
return s.getUInt("buyOutFeePercentage");
}
}
| 189,430 | 11,926 |
3c08e43d433e56fda1132c82599a750d158e12d008ceaa41a50ff4f5096b7914
| 17,267 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x44d5a250eca51421bda2d337a0155a96ab9687d8.sol
| 2,882 | 10,278 |
pragma solidity ^0.4.11;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract ReleasableToken is MintableToken {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
contract GlobalBusinessSystemToken is ReleasableToken {
string public constant name = "Global Business System Token";
string public constant symbol = "GBST";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 0;
function GlobalBusinessSystemToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
setReleaseAgent(msg.sender);
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
uint bonusPeriod = 7;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
//require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
uint256 bonusTokens = 0;
if(now < (startTime + bonusPeriod * 1 days)) {
bonusTokens = tokens.div(5); //20%
}
tokens += bonusTokens;
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool minValue = msg.value >= 10000000000000000;
return withinPeriod && nonZeroPurchase && minValue;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) {
require(_cap > 0);
cap = _cap * 1000000000000000000;
}
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract GlobalBusinessSystem is CappedCrowdsale,FinalizableCrowdsale {
function GlobalBusinessSystem(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet)
CappedCrowdsale(_cap)
FinalizableCrowdsale()
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
//As goal needs to be met for a successful crowdsale
//the value needs to less or equal than a cap which is limit for accepted funds
//require(_goal <= _cap);
}
function createTokenContract() internal returns (MintableToken) {
return new GlobalBusinessSystemToken();
}
}
| 145,451 | 11,927 |
2e5c6b90935f6e34c56f89c898498e5e05352533e620a0549043e347219503af
| 17,452 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TN5J66jkwfxqyXWBibxajAuisrb9V8ge6C_AlricanHarvest.sol
| 4,539 | 17,263 |
//SourceUnit: alricanharvest.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract AlricanHarvest {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 500;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 25000000 trx;
uint constant public LEADER_BONUS_STEP = 5000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 100000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 500 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 306,513 | 11,928 |
6d701a6e004c9da710c0fe3a464bc82f76471b9548376a7a9449c5621a4497af
| 20,815 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0x4ceda7906a5ed2179785cd3a40a69ee8bc99c466.sol
| 3,382 | 13,789 |
pragma solidity >=0.4.10;
// from Zeppelin
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
require(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
require(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
require(c>=a && c>=b);
return c;
}
}
contract Owned {
address public owner;
address newOwner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
contract IToken {
function transfer(address _to, uint _value) returns (bool);
function balanceOf(address owner) returns(uint);
}
// In case someone accidentally sends token to one of these contracts,
// add a way to get them back out.
contract TokenReceivable is Owned {
function claimTokens(address _token, address _to) onlyOwner returns (bool) {
IToken token = IToken(_token);
return token.transfer(_to, token.balanceOf(this));
}
}
contract EventDefinitions {
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Burn(address indexed from, bytes32 indexed to, uint value);
event Claimed(address indexed claimer, uint value);
}
contract Pausable is Owned {
bool public paused;
function pause() onlyOwner {
paused = true;
}
function unpause() onlyOwner {
paused = false;
}
modifier notPaused() {
require(!paused);
_;
}
}
contract Finalizable is Owned {
bool public finalized;
function finalize() onlyOwner {
finalized = true;
}
modifier notFinalized() {
require(!finalized);
_;
}
}
contract Ledger is Owned, SafeMath, Finalizable {
Controller public controller;
mapping(address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint public totalSupply;
uint public mintingNonce;
bool public mintingStopped;
mapping(uint256 => bytes32) public proofs;
mapping(address => uint256) public locked;
mapping(bytes32 => bytes32) public metadata;
address public burnAddress;
mapping(address => bool) public bridgeNodes;
// functions below this line are onlyOwner
function Ledger() {
}
function setController(address _controller) onlyOwner notFinalized {
controller = Controller(_controller);
}
function stopMinting() onlyOwner {
mintingStopped = true;
}
function multiMint(uint nonce, uint256[] bits) onlyOwner {
require(!mintingStopped);
if (nonce != mintingNonce) return;
mintingNonce += 1;
uint256 lomask = (1 << 96) - 1;
uint created = 0;
for (uint i=0; i<bits.length; i++) {
address a = address(bits[i]>>96);
uint value = bits[i]&lomask;
balanceOf[a] = balanceOf[a] + value;
controller.ledgerTransfer(0, a, value);
created += value;
}
totalSupply += created;
}
// functions below this line are onlyController
modifier onlyController() {
require(msg.sender == address(controller));
_;
}
function transfer(address _from, address _to, uint _value) onlyController returns (bool success) {
if (balanceOf[_from] < _value) return false;
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
return true;
}
function transferFrom(address _spender, address _from, address _to, uint _value) onlyController returns (bool success) {
if (balanceOf[_from] < _value) return false;
var allowed = allowance[_from][_spender];
if (allowed < _value) return false;
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
allowance[_from][_spender] = safeSub(allowed, _value);
return true;
}
function approve(address _owner, address _spender, uint _value) onlyController returns (bool success) {
// require user to set to zero before resetting to nonzero
if ((_value != 0) && (allowance[_owner][_spender] != 0)) {
return false;
}
allowance[_owner][_spender] = _value;
return true;
}
function increaseApproval (address _owner, address _spender, uint _addedValue) onlyController returns (bool success) {
uint oldValue = allowance[_owner][_spender];
allowance[_owner][_spender] = safeAdd(oldValue, _addedValue);
return true;
}
function decreaseApproval (address _owner, address _spender, uint _subtractedValue) onlyController returns (bool success) {
uint oldValue = allowance[_owner][_spender];
if (_subtractedValue > oldValue) {
allowance[_owner][_spender] = 0;
} else {
allowance[_owner][_spender] = safeSub(oldValue, _subtractedValue);
}
return true;
}
function setProof(uint256 _key, bytes32 _proof) onlyController {
proofs[_key] = _proof;
}
function setLocked(address _key, uint256 _value) onlyController {
locked[_key] = _value;
}
function setMetadata(bytes32 _key, bytes32 _value) onlyController {
metadata[_key] = _value;
}
function setBurnAddress(address _address) onlyController {
burnAddress = _address;
}
function setBridgeNode(address _address, bool enabled) onlyController {
bridgeNodes[_address] = enabled;
}
}
contract ControllerEventDefinitions {
event ControllerBurn(address indexed from, bytes32 indexed to, uint value);
}
contract Controller is Owned, Finalizable, ControllerEventDefinitions {
Ledger public ledger;
Token public token;
address public burnAddress;
function Controller() {
}
// functions below this line are onlyOwner
function setToken(address _token) onlyOwner {
token = Token(_token);
}
function setLedger(address _ledger) onlyOwner {
ledger = Ledger(_ledger);
}
function setBurnAddress(address _address) onlyOwner {
burnAddress = _address;
ledger.setBurnAddress(_address);
token.setBurnAddress(_address);
}
modifier onlyToken() {
require(msg.sender == address(token));
_;
}
modifier onlyLedger() {
require(msg.sender == address(ledger));
_;
}
function totalSupply() constant returns (uint) {
return ledger.totalSupply();
}
function balanceOf(address _a) constant returns (uint) {
return ledger.balanceOf(_a);
}
function allowance(address _owner, address _spender) constant returns (uint) {
return ledger.allowance(_owner, _spender);
}
// functions below this line are onlyLedger
// let the ledger send transfer events (the most obvious case
// is when we mint directly to the ledger and need the Transfer()
// events to appear in the token)
function ledgerTransfer(address from, address to, uint val) onlyLedger {
token.controllerTransfer(from, to, val);
}
// functions below this line are onlyToken
function transfer(address _from, address _to, uint _value) onlyToken returns (bool success) {
return ledger.transfer(_from, _to, _value);
}
function transferFrom(address _spender, address _from, address _to, uint _value) onlyToken returns (bool success) {
return ledger.transferFrom(_spender, _from, _to, _value);
}
function approve(address _owner, address _spender, uint _value) onlyToken returns (bool success) {
return ledger.approve(_owner, _spender, _value);
}
function increaseApproval (address _owner, address _spender, uint _addedValue) onlyToken returns (bool success) {
return ledger.increaseApproval(_owner, _spender, _addedValue);
}
function decreaseApproval (address _owner, address _spender, uint _subtractedValue) onlyToken returns (bool success) {
return ledger.decreaseApproval(_owner, _spender, _subtractedValue);
}
function enableBurning() onlyOwner {
token.enableBurning();
}
function disableBurning() onlyOwner {
token.disableBurning();
}
// public functions
function burn(address _from, bytes32 _to, uint _amount) onlyToken returns (bool success) {
if (ledger.transfer(_from, burnAddress, _amount)) {
ControllerBurn(_from, _to, _amount);
token.controllerBurn(_from, _to, _amount);
return true;
}
return false;
}
function claimByProof(address _claimer, bytes32[] data, bytes32[] proofs, uint256 number)
onlyToken
returns (bool success) {
return false;
}
function claim(address _claimer) onlyToken returns (bool success) {
return false;
}
}
contract Token is Finalizable, TokenReceivable, SafeMath, EventDefinitions, Pausable {
// Set these appropriately before you deploy
string constant public name = "AION";
uint8 constant public decimals = 8;
string constant public symbol = "AION";
Controller public controller;
string public motd;
event Motd(string message);
address public burnAddress; //@ATTENTION: set this to a correct value
bool public burnable = false;
// functions below this line are onlyOwner
// set "message of the day"
function setMotd(string _m) onlyOwner {
motd = _m;
Motd(_m);
}
function setController(address _c) onlyOwner notFinalized {
controller = Controller(_c);
}
// functions below this line are public
function balanceOf(address a) constant returns (uint) {
return controller.balanceOf(a);
}
function totalSupply() constant returns (uint) {
return controller.totalSupply();
}
function allowance(address _owner, address _spender) constant returns (uint) {
return controller.allowance(_owner, _spender);
}
function transfer(address _to, uint _value) notPaused returns (bool success) {
if (controller.transfer(msg.sender, _to, _value)) {
Transfer(msg.sender, _to, _value);
return true;
}
return false;
}
function transferFrom(address _from, address _to, uint _value) notPaused returns (bool success) {
if (controller.transferFrom(msg.sender, _from, _to, _value)) {
Transfer(_from, _to, _value);
return true;
}
return false;
}
function approve(address _spender, uint _value) notPaused returns (bool success) {
// promote safe user behavior
if (controller.approve(msg.sender, _spender, _value)) {
Approval(msg.sender, _spender, _value);
return true;
}
return false;
}
function increaseApproval (address _spender, uint _addedValue) notPaused returns (bool success) {
if (controller.increaseApproval(msg.sender, _spender, _addedValue)) {
uint newval = controller.allowance(msg.sender, _spender);
Approval(msg.sender, _spender, newval);
return true;
}
return false;
}
function decreaseApproval (address _spender, uint _subtractedValue) notPaused returns (bool success) {
if (controller.decreaseApproval(msg.sender, _spender, _subtractedValue)) {
uint newval = controller.allowance(msg.sender, _spender);
Approval(msg.sender, _spender, newval);
return true;
}
return false;
}
// modifier onlyPayloadSize(uint numwords) {
// assert(msg.data.length >= numwords * 32 + 4);
// _;
// }
// functions below this line are onlyController
modifier onlyController() {
assert(msg.sender == address(controller));
_;
}
// In the future, when the controller supports multiple token
// heads, allow the controller to reconstitute the transfer and
// approval history.
function controllerTransfer(address _from, address _to, uint _value) onlyController {
Transfer(_from, _to, _value);
}
function controllerApprove(address _owner, address _spender, uint _value) onlyController {
Approval(_owner, _spender, _value);
}
function controllerBurn(address _from, bytes32 _to, uint256 _value) onlyController {
Burn(_from, _to, _value);
}
function controllerClaim(address _claimer, uint256 _value) onlyController {
Claimed(_claimer, _value);
}
function setBurnAddress(address _address) onlyController {
burnAddress = _address;
}
function enableBurning() onlyController {
burnable = true;
}
function disableBurning() onlyController {
burnable = false;
}
modifier burnEnabled() {
require(burnable == true);
_;
}
function burn(bytes32 _to, uint _amount) notPaused burnEnabled returns (bool success) {
return controller.burn(msg.sender, _to, _amount);
}
function claimByProof(bytes32[] data, bytes32[] proofs, uint256 number) notPaused burnEnabled returns (bool success) {
return controller.claimByProof(msg.sender, data, proofs, number);
}
function claim() notPaused burnEnabled returns (bool success) {
return controller.claim(msg.sender);
}
}
| 20,153 | 11,929 |
b3996609dca9b79487f41d1c602bf58a480dfe5f021dd4783ea880e640d51614
| 18,834 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0xec841c878435ba4f28bf305a00c1483db0d96a20.sol
| 4,617 | 18,053 |
pragma solidity ^0.4.24;
// File: contracts/database/Database.sol
// @title A shared storage contract for platform contracts to store and retrieve data
// @notice This contract holds all long-term data for smart-contract systems
// @dev The bytes32 hashes are derived from keccak256(variableName, uniqueID) => value
// @dec Can enable upgradeable contracts by setting a contract manager
contract Database{
// Storage Variables
mapping(bytes32 => uint) public uintStorage;
mapping(bytes32 => string) public stringStorage;
mapping(bytes32 => address) public addressStorage;
mapping(bytes32 => bytes) public bytesStorage;
mapping(bytes32 => bytes32) public bytes32Storage;
mapping(bytes32 => bool) public boolStorage;
mapping(bytes32 => int) public intStorage;
// @notice Constructor: Sets the owners of the platform
// @dev Owners must set the contract manager to add more contracts
constructor(address[] _owners, bool _upgradeable)
public {
for(uint i=0; i<_owners.length; i++){
require(_owners[i] != address(0), "Empty address");
boolStorage[keccak256(abi.encodePacked("owner", _owners[i]))] = true;
emit LogInitialized(_owners[i], _upgradeable);
}
if (_upgradeable){
boolStorage[keccak256("upgradeable")] = true;
}
}
// @notice ContractManager will be the only contract that can add/remove contracts on the platform.
// @param (address) _contractManager is the contract which can upgrade/remove contracts to platform
function enableContractManagement(address _contractManager)
external
returns (bool){
require(_contractManager != address(0), "Empty address");
require(boolStorage[keccak256(abi.encodePacked("owner", msg.sender))], "Not owner");
require(addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] == address(0), "There is already a contract manager");
addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] = _contractManager;
boolStorage[keccak256(abi.encodePacked("contract", _contractManager))] = true;
return true;
}
// @notice Storage functions
function setAddress(bytes32 _key, address _value)
onlyApprovedContract
external {
addressStorage[_key] = _value;
}
function setUint(bytes32 _key, uint _value)
onlyApprovedContract
external {
uintStorage[_key] = _value;
}
function setString(bytes32 _key, string _value)
onlyApprovedContract
external {
stringStorage[_key] = _value;
}
function setBytes(bytes32 _key, bytes _value)
onlyApprovedContract
external {
bytesStorage[_key] = _value;
}
function setBytes32(bytes32 _key, bytes32 _value)
onlyApprovedContract
external {
bytes32Storage[_key] = _value;
}
function setBool(bytes32 _key, bool _value)
onlyApprovedContract
external {
boolStorage[_key] = _value;
}
function setInt(bytes32 _key, int _value)
onlyApprovedContract
external {
intStorage[_key] = _value;
}
// Deletion functions: Can alternatively use setter functions and set to null value (ie. uint = 0)
function deleteAddress(bytes32 _key)
onlyApprovedContract
external {
delete addressStorage[_key];
}
function deleteUint(bytes32 _key)
onlyApprovedContract
external {
delete uintStorage[_key];
}
function deleteString(bytes32 _key)
onlyApprovedContract
external {
delete stringStorage[_key];
}
function deleteBytes(bytes32 _key)
onlyApprovedContract
external {
delete bytesStorage[_key];
}
function deleteBytes32(bytes32 _key)
onlyApprovedContract
external {
delete bytes32Storage[_key];
}
function deleteBool(bytes32 _key)
onlyApprovedContract
external {
delete boolStorage[_key];
}
function deleteInt(bytes32 _key)
onlyApprovedContract
external {
delete intStorage[_key];
}
// --------------------------------------------------------------------------------------
// Modifiers
// --------------------------------------------------------------------------------------
// Caller must be registered as a contract through ContractManager.sol
modifier onlyApprovedContract() {
require(boolStorage[keccak256(abi.encodePacked("contract", msg.sender))]);
_;
}
// --------------------------------------------------------------------------------------
// Events
// --------------------------------------------------------------------------------------
event LogInitialized(address _owner, bool _upgradeable);
}
// File: contracts/interfaces/DBInterface.sol
// Database interface
interface DBInterface {
function setContractManager(address _contractManager)
external;
// --------------------Set Functions------------------------
function setAddress(bytes32 _key, address _value)
external;
function setUint(bytes32 _key, uint _value)
external;
function setString(bytes32 _key, string _value)
external;
function setBytes(bytes32 _key, bytes _value)
external;
function setBytes32(bytes32 _key, bytes32 _value)
external;
function setBool(bytes32 _key, bool _value)
external;
function setInt(bytes32 _key, int _value)
external;
// -------------- Deletion Functions ------------------
function deleteAddress(bytes32 _key)
external;
function deleteUint(bytes32 _key)
external;
function deleteString(bytes32 _key)
external;
function deleteBytes(bytes32 _key)
external;
function deleteBytes32(bytes32 _key)
external;
function deleteBool(bytes32 _key)
external;
function deleteInt(bytes32 _key)
external;
// ----------------Variable Getters---------------------
function uintStorage(bytes32 _key)
external
view
returns (uint);
function stringStorage(bytes32 _key)
external
view
returns (string);
function addressStorage(bytes32 _key)
external
view
returns (address);
function bytesStorage(bytes32 _key)
external
view
returns (bytes);
function bytes32Storage(bytes32 _key)
external
view
returns (bytes32);
function boolStorage(bytes32 _key)
external
view
returns (bool);
function intStorage(bytes32 _key)
external
view
returns (bool);
}
// File: contracts/database/Events.sol
contract Events {
DBInterface public database;
constructor(address _database) public{
database = DBInterface(_database);
}
function message(string _message)
external
onlyApprovedContract {
emit LogEvent(_message, keccak256(abi.encodePacked(_message)), tx.origin);
}
function transaction(string _message, address _from, address _to, uint _amount, address _token)
external
onlyApprovedContract {
emit LogTransaction(_message, keccak256(abi.encodePacked(_message)), _from, _to, _amount, _token, tx.origin);
}
function registration(string _message, address _account)
external
onlyApprovedContract {
emit LogAddress(_message, keccak256(abi.encodePacked(_message)), _account, tx.origin);
}
function contractChange(string _message, address _account, string _name)
external
onlyApprovedContract {
emit LogContractChange(_message, keccak256(abi.encodePacked(_message)), _account, _name, tx.origin);
}
function asset(string _message, string _uri, address _assetAddress, address _manager)
external
onlyApprovedContract {
emit LogAsset(_message, keccak256(abi.encodePacked(_message)), _uri, keccak256(abi.encodePacked(_uri)), _assetAddress, _manager, tx.origin);
}
function escrow(string _message, address _assetAddress, bytes32 _escrowID, address _manager, uint _amount)
external
onlyApprovedContract {
emit LogEscrow(_message, keccak256(abi.encodePacked(_message)), _assetAddress, _escrowID, _manager, _amount, tx.origin);
}
function order(string _message, bytes32 _orderID, uint _amount, uint _price)
external
onlyApprovedContract {
emit LogOrder(_message, keccak256(abi.encodePacked(_message)), _orderID, _amount, _price, tx.origin);
}
function exchange(string _message, bytes32 _orderID, address _assetAddress, address _account)
external
onlyApprovedContract {
emit LogExchange(_message, keccak256(abi.encodePacked(_message)), _orderID, _assetAddress, _account, tx.origin);
}
function operator(string _message, bytes32 _id, string _name, string _ipfs, address _account)
external
onlyApprovedContract {
emit LogOperator(_message, keccak256(abi.encodePacked(_message)), _id, _name, _ipfs, _account, tx.origin);
}
function consensus(string _message, bytes32 _executionID, bytes32 _votesID, uint _votes, uint _tokens, uint _quorum)
external
onlyApprovedContract {
emit LogConsensus(_message, keccak256(abi.encodePacked(_message)), _executionID, _votesID, _votes, _tokens, _quorum, tx.origin);
}
//Generalized events
event LogEvent(string message, bytes32 indexed messageID, address indexed origin);
event LogTransaction(string message, bytes32 indexed messageID, address indexed from, address indexed to, uint amount, address token, address origin); //amount and token will be empty on some events
event LogAddress(string message, bytes32 indexed messageID, address indexed account, address indexed origin);
event LogContractChange(string message, bytes32 indexed messageID, address indexed account, string name, address indexed origin);
event LogAsset(string message, bytes32 indexed messageID, string uri, bytes32 indexed assetID, address asset, address manager, address indexed origin);
event LogEscrow(string message, bytes32 indexed messageID, address asset, bytes32 escrowID, address indexed manager, uint amount, address indexed origin);
event LogOrder(string message, bytes32 indexed messageID, bytes32 indexed orderID, uint amount, uint price, address indexed origin);
event LogExchange(string message, bytes32 indexed messageID, bytes32 orderID, address indexed asset, address account, address indexed origin);
event LogOperator(string message, bytes32 indexed messageID, bytes32 id, string name, string ipfs, address indexed account, address indexed origin);
event LogConsensus(string message, bytes32 indexed messageID, bytes32 executionID, bytes32 votesID, uint votes, uint tokens, uint quorum, address indexed origin);
// --------------------------------------------------------------------------------------
// Caller must be registered as a contract through ContractManager.sol
// --------------------------------------------------------------------------------------
modifier onlyApprovedContract() {
require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
_;
}
}
// File: contracts/roles/Operators.sol
contract Operators {
Database public database;
Events public events;
constructor(address _database, address _events) public {
database = Database(_database);
events = Events(_events);
}
// @notice allows the platform owners to onboard a new operator.
function registerOperator(address _operatorAddress, string _operatorURI, string _ipfs, address _referrerAddress)
external
onlyOwner {
require(_operatorAddress != address(0));
bytes32 operatorID = keccak256(abi.encodePacked("operator.uri", _operatorURI));
require(database.addressStorage(keccak256(abi.encodePacked("operator", operatorID))) == address(0));
database.setBytes32(keccak256(abi.encodePacked("operator", _operatorAddress)), operatorID);
database.setAddress(keccak256(abi.encodePacked("operator", operatorID)), _operatorAddress);
database.setString(keccak256(abi.encodePacked("operator.ipfs", operatorID)), _ipfs);
if(_referrerAddress == address(0)){
database.setAddress(keccak256(abi.encodePacked("referrer", operatorID)), database.addressStorage(keccak256(abi.encodePacked("platform.wallet.assets"))));
} else {
database.setAddress(keccak256(abi.encodePacked("referrer", operatorID)), _referrerAddress);
}
events.operator('Operator registered', operatorID, _operatorURI, _ipfs, _operatorAddress);
}
// @notice owners can remove operators from the platform here
function removeOperator(bytes32 _operatorID)
external {
address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) || msg.sender == operatorAddress);
database.deleteBytes32(keccak256(abi.encodePacked("operator", operatorAddress)));
database.deleteAddress(keccak256(abi.encodePacked("operator", _operatorID)));
database.deleteAddress(keccak256(abi.encodePacked("referrer", _operatorID)));
events.operator('Operator removed', _operatorID, '', '', msg.sender);
}
// @notice operator or owner can change the withdraw address of a registered operator
function changeOperatorAddress(bytes32 _operatorID, address _newAddress)
external {
address oldAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
require(oldAddress != address(0));
require(msg.sender == oldAddress || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
database.setAddress(keccak256(abi.encodePacked("operator", _operatorID)), _newAddress);
database.deleteBytes32(keccak256(abi.encodePacked("operator", oldAddress)));
database.setBytes32(keccak256(abi.encodePacked("operator", _newAddress)), _operatorID);
events.operator('Operator address changed', _operatorID, '', '', _newAddress);
}
function changeReferrerAddress(bytes32 _operatorID, address _newAddress)
external {
address oldAddress = database.addressStorage(keccak256(abi.encodePacked("referrer", _operatorID)));
require(oldAddress != address(0));
require(msg.sender == oldAddress || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
database.setAddress(keccak256(abi.encodePacked("referrer", _operatorID)), _newAddress);
events.operator('Referrer address changed', _operatorID, '', '', _newAddress);
}
function updateIPFS(bytes32 _operatorID, string _ipfs)
external
onlyOperator(_operatorID)
returns(bool){
database.setString(keccak256(abi.encodePacked("operator.ipfs", _operatorID)), _ipfs);
events.operator('Operator ipfs', _operatorID, '', _ipfs, msg.sender);
}
function addAsset(bytes32 _operatorID, string _name, string _ipfs, bool _acceptCrypto, bool _payoutCrypto, address _token)
external
onlyOperator(_operatorID)
returns (bool) {
address operator = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
bytes32 modelID = keccak256(abi.encodePacked('model.id', _operatorID, _name));
require(database.addressStorage(keccak256(abi.encodePacked("model.operator", modelID))) == address(0));
database.setAddress(keccak256(abi.encodePacked("model.operator", modelID)), operator);
database.setString(keccak256(abi.encodePacked('model.ipfs', modelID)), _ipfs);
acceptToken(modelID, _token, _acceptCrypto);
payoutToken(modelID, _token, _payoutCrypto);
events.operator('Asset added', modelID, _name, _ipfs, operator);
return true;
}
function removeAsset(bytes32 _modelID)
external
onlyOperator(_modelID)
returns (bool) {
database.deleteAddress(keccak256(abi.encodePacked("model.operator", _modelID)));
database.deleteString(keccak256(abi.encodePacked('model.ipfs', _modelID)));
events.operator('Asset removed', _modelID, '', '', msg.sender);
}
function updateModelIPFS(bytes32 _modelID, string _ipfs)
external
onlyOperator(_modelID)
returns(bool){
database.setString(keccak256(abi.encodePacked("model.ipfs", _modelID)), _ipfs);
events.operator('Model ipfs', _modelID, '', _ipfs, msg.sender);
}
function updateModelOperator(bytes32 _modelID, address _newAddress)
external
onlyOperator(_modelID)
returns(bool){
database.setAddress(keccak256(abi.encodePacked("model.operator", _modelID)), _newAddress);
events.operator('Model operator', _modelID, '', '', _newAddress);
}
// @notice operator can choose which ERC20 tokens he's willing to accept as payment
function acceptToken(bytes32 _modelID, address _tokenAddress, bool _accept)
public
onlyOperator(_modelID)
returns (bool) {
if(_tokenAddress == address(0)){
database.setBool(keccak256(abi.encodePacked("model.acceptsEther", _modelID)), _accept);
}
database.setBool(keccak256(abi.encodePacked("model.acceptsToken", _modelID, _tokenAddress)), _accept);
return true;
}
// @notice operator can choose which ERC20 tokens it pays out with
function payoutToken(bytes32 _modelID, address _tokenAddress, bool _payout)
public
onlyOperator(_modelID)
returns (bool) {
if(_tokenAddress == address(0)){
database.setBool(keccak256(abi.encodePacked("model.payoutEther", _modelID)), _payout);
}
database.setBool(keccak256(abi.encodePacked("model.payoutToken", _modelID, _tokenAddress)), _payout);
return true;
}
// @notice platform owners can destroy contract here
function destroy()
onlyOwner
external {
events.transaction('Operators destroyed', address(this), msg.sender, address(this).balance, address(0));
selfdestruct(msg.sender);
}
// @notice Sender must be a registered owner
modifier onlyOwner {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
_;
}
modifier onlyOperator(bytes32 _id) {
require(database.addressStorage(keccak256(abi.encodePacked("operator", _id))) == msg.sender || database.addressStorage(keccak256(abi.encodePacked("model.operator", _id))) == msg.sender || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
_;
}
}
| 339,894 | 11,930 |
0d14d922caa174602b20ad2edef82997048ab4b42b93960e9ec38d1c3f3cbab8
| 17,976 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/publicFuncToExternal/manualCheck/0x1d8a3ff449c2baab6aee62f514ae0db7cde4ae75_publicFuncToExternal.sol
| 5,280 | 17,598 |
pragma solidity ^0.5.15;
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 Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _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 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 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;
}
}
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;
function rewards() external view returns (address);
}
// vault1111 111111111111
// abi1111: https://github.com/ystar-foundation/YstarFarming/blob/master/Vault/abi/vault.json
contract Vault {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public token;
IERC20 public YFToken; // YF1111
uint public min = 9500;
uint public constant max = 10000;
uint public earnLowerlimit; //1111111111111earn
address public governance;
address public controller;
struct Player {
uint256 stake; // 1111
uint256 payout; // 11
uint256 total_out; // 1111111
}
mapping(address => Player) public player_; // (player => data) player data
struct Global {
uint256 total_stake; // 11111
uint256 total_out; // 11111
uint256 earnings_per_share; // 1111
}
mapping(uint256 => Global) public global_; // (global => data) global data
mapping (address => uint256) public deposittime;
uint256 constant internal magnitude = 10**40; // 1014011
address constant public yf = address(0x96F9632b25f874769969ff91219fCCb6ceDf26D2);
string public getName;
constructor (address _token, uint256 _earnLowerlimit) public {
token = IERC20(_token);
getName = string(abi.encodePacked("yf:Vault:", ERC20Detailed(_token).name()));
earnLowerlimit = _earnLowerlimit*1e18;
YFToken = IERC20(yf);
governance = tx.origin;
controller = 0xcC8d36211374a08fC61d74ed2E48e22b922C9D7C;
}
function balance() public view returns (uint) {
return token.balanceOf(address(this))
.add(Controller(controller).balanceOf(address(token)));
}
function setMin(uint _min) public { //inject PUBLIC FUNC TO EXTERNAL
require(msg.sender == governance, "!governance");
min = _min;
}
// 11111111111111111111
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
// 1111token
function setToken(address _token) public {
require(msg.sender == governance, "!governance");
token = IERC20(_token);
}
// 1111111111111111111
function setController(address _controller) public {
require(msg.sender == governance, "!governance");
controller = _controller;
}
function setEarnLowerlimit(uint256 _earnLowerlimit) public{
require(msg.sender == governance, "!governance");
earnLowerlimit = _earnLowerlimit;
}
// Custom logic in here for how much the vault allows to be borrowed
// Sets minimum required on-hand to keep small withdrawals cheap
// 11111111111
// 111111111111111111111
function available() public view returns (uint) {
return token.balanceOf(address(this)).mul(min).div(max); // balance*min/max 1111111111111111111
}
// 11111Strategy1111111111111 vault->controller->strategy
function earn() public {
uint _bal = available(); // 1111111111111111111111
token.safeTransfer(controller, _bal); // 1111111
Controller(controller).earn(address(token), _bal); // 11111Strategy111111
}
// 11 111111
function deposit(uint amount) public { //inject PUBLIC FUNC TO EXTERNAL
// 111111111111111111appove1111111111111
token.safeTransferFrom(msg.sender, address(this), amount);
// 1111111111
player_[msg.sender].stake = player_[msg.sender].stake.add(amount);
// 11111110
if (global_[0].earnings_per_share != 0) {
player_[msg.sender].payout = player_[msg.sender].payout.add(global_[0].earnings_per_share.mul(amount).sub(1).div(magnitude).add(1) // (((earnings_per_share*amount)-1)/magnitude)+1);
}
// 1111111111
global_[0].total_stake = global_[0].total_stake.add(amount);
// 111111111111111111111111111111111111111111111
if (token.balanceOf(address(this)) > earnLowerlimit){
earn();
}
// 11111111
deposittime[msg.sender] = now;
}
// No rebalance implementation for lower fees and faster swaps
// 11
function withdraw(uint amount) public { //inject PUBLIC FUNC TO EXTERNAL
claim(); // 111111111111
require(amount <= player_[msg.sender].stake, "!balance");
uint r = amount;
// Check balance
uint b = token.balanceOf(address(this));
if (b < r) { // 11vault111111111111111111111Strategy11111111111
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw); // 11
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (_diff < _withdraw) { // 111111111111111111111vault111111
r = b.add(_diff);
}
}
// 111111111111111111111
player_[msg.sender].payout = player_[msg.sender].payout.sub(global_[0].earnings_per_share.mul(amount).div(magnitude));
// 1111111111111
player_[msg.sender].stake = player_[msg.sender].stake.sub(amount);
global_[0].total_stake = global_[0].total_stake.sub(amount);
// 1111111111
token.safeTransfer(msg.sender, r);
}
// Strategy.harvest 111111
function make_profit(uint256 amount) public {
require(amount > 0, "not 0");
YFToken.safeTransferFrom(msg.sender, address(this), amount); // 1111111111111110%1111190%1111111
global_[0].earnings_per_share = global_[0].earnings_per_share.add(amount.mul(magnitude).div(global_[0].total_stake));
global_[0].total_out = global_[0].total_out.add(amount);
}
// 11111111
function cal_out(address user) public view returns (uint256) {
uint256 _cal = global_[0].earnings_per_share.mul(player_[user].stake).div(magnitude);
if (_cal < player_[user].payout) {
return 0;
} else {
return _cal.sub(player_[user].payout);
}
}
// 11111111111111111111111111.11111111111harvest1111111111
function cal_out_pending(uint256 _pendingBalance,address user) public view returns (uint256) {
uint256 _earnings_per_share = global_[0].earnings_per_share.add(_pendingBalance.mul(magnitude).div(global_[0].total_stake));
uint256 _cal = _earnings_per_share.mul(player_[user].stake).div(magnitude);
_cal = _cal.sub(cal_out(user));
if (_cal < player_[user].payout) {
return 0;
} else {
return _cal.sub(player_[user].payout);
}
}
// 111111
function claim() public {
uint256 out = cal_out(msg.sender);
player_[msg.sender].payout = global_[0].earnings_per_share.mul(player_[msg.sender].stake).div(magnitude);
player_[msg.sender].total_out = player_[msg.sender].total_out.add(out);
if (out > 0) {
uint256 _depositTime = now - deposittime[msg.sender];
if (_depositTime < 1 days){ // deposit in 24h
uint256 actually_out = _depositTime.mul(out).mul(1e18).div(1 days).div(1e18);
uint256 to_team = out.sub(actually_out);
YFToken.safeTransfer(Controller(controller).rewards(), to_team);
out = actually_out;
}
YFToken.safeTransfer(msg.sender, out);
}
}
}
| 277,719 | 11,931 |
721bbaccc3266e1322a656153b8c1a391e77f5f18a73f31936bfc728a4effced
| 17,742 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/nonStandarNaming/0x5edf5432c6dc5b42c9ec01fa9443c3ac89ca9686_nonStandardNaming.sol
| 3,772 | 12,859 |
pragma solidity ^0.5.1;
library SafeMath {
function MUL493(uint256 _a, uint256 _b) internal pure returns (uint256 c) { //inject NONSTANDARD NAMING
// 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 DIV994(uint256 _a, uint256 _b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 SUB747(uint256 _a, uint256 _b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
assert(_b <= _a);
return _a - _b;
}
function ADD196(uint256 _a, uint256 _b) internal pure returns (uint256 c) { //inject NONSTANDARD NAMING
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OWNERSHIPRENOUNCED804(address indexed previousOwner); //inject NONSTANDARD NAMING
event OWNERSHIPTRANSFERRED780(//inject NONSTANDARD NAMING
address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier ONLYOWNER146() { //inject NONSTANDARD NAMING
require(msg.sender == owner);
_;
}
function RENOUNCEOWNERSHIP303() public ONLYOWNER146 { //inject NONSTANDARD NAMING
emit OWNERSHIPRENOUNCED804(owner);
owner = address(0);
}
function TRANSFEROWNERSHIP59(address _newOwner) public ONLYOWNER146 { //inject NONSTANDARD NAMING
_TRANSFEROWNERSHIP932(_newOwner);
}
function _TRANSFEROWNERSHIP932(address _newOwner) internal { //inject NONSTANDARD NAMING
require(_newOwner != address(0));
emit OWNERSHIPTRANSFERRED780(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event PAUSE575(); //inject NONSTANDARD NAMING
event UNPAUSE64(); //inject NONSTANDARD NAMING
bool public paused = false;
modifier WHENNOTPAUSED282() { //inject NONSTANDARD NAMING
require(!paused);
_;
}
modifier WHENPAUSED855() { //inject NONSTANDARD NAMING
require(paused);
_;
}
function PAUSE602() public ONLYOWNER146 WHENNOTPAUSED282 { //inject NONSTANDARD NAMING
paused = true;
emit PAUSE575();
}
function UNPAUSE899() public ONLYOWNER146 WHENPAUSED855 { //inject NONSTANDARD NAMING
paused = false;
emit UNPAUSE64();
}
}
contract ERC20Basic {
function TOTALSUPPLY769() public view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF878(address _who) public view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER201(address _to, uint256 _value) public returns (bool); //inject NONSTANDARD NAMING
event TRANSFER93(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function TOTALSUPPLY769() public view returns (uint256) { //inject NONSTANDARD NAMING
return totalSupply_;
}
function TRANSFER201(address _to, uint256 _value) public returns (bool) { //inject NONSTANDARD NAMING
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].SUB747(_value);
balances[_to] = balances[_to].ADD196(_value);
emit TRANSFER93(msg.sender, _to, _value);
return true;
}
function BALANCEOF878(address _owner) public view returns (uint256) { //inject NONSTANDARD NAMING
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function ALLOWANCE103(address _owner, address _spender) public view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFERFROM299(address _from, address _to, uint256 _value) public returns (bool); //inject NONSTANDARD NAMING
function APPROVE456(address _spender, uint256 _value) public returns (bool); //inject NONSTANDARD NAMING
event APPROVAL162(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function TRANSFERFROM299(address _from, address _to, uint256 _value) //inject NONSTANDARD NAMING
public returns (bool) {
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].SUB747(_value);
balances[_to] = balances[_to].ADD196(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].SUB747(_value);
emit TRANSFER93(_from, _to, _value);
return true;
}
function APPROVE456(address _spender, uint256 _value) public returns (bool) { //inject NONSTANDARD NAMING
allowed[msg.sender][_spender] = _value;
emit APPROVAL162(msg.sender, _spender, _value);
return true;
}
function ALLOWANCE103(address _owner, address _spender) //inject NONSTANDARD NAMING
public view returns (uint256) {
return allowed[_owner][_spender];
}
function INCREASEAPPROVAL281(address _spender, uint256 _addedValue) //inject NONSTANDARD NAMING
public returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].ADD196(_addedValue));
emit APPROVAL162(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function DECREASEAPPROVAL320(address _spender, uint256 _subtractedValue) //inject NONSTANDARD NAMING
public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) allowed[msg.sender][_spender] = 0;
else allowed[msg.sender][_spender] = oldValue.SUB747(_subtractedValue);
emit APPROVAL162(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken, Ownable {
event BURN461(address indexed burner, uint256 value); //inject NONSTANDARD NAMING
function BURN801(address _who, uint256 _value) ONLYOWNER146 public { //inject NONSTANDARD NAMING
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].SUB747(_value);
totalSupply_ = totalSupply_.SUB747(_value);
emit BURN461(_who, _value);
emit TRANSFER93(_who, address(0), _value);
}
}
contract MintableToken is StandardToken, Ownable {
event MINT447(address indexed to, uint256 amount); //inject NONSTANDARD NAMING
event MINTFINISHED751(); //inject NONSTANDARD NAMING
bool public mintingFinished = false;
modifier CANMINT819() { //inject NONSTANDARD NAMING
require(!mintingFinished);
_;
}
modifier HASMINTPERMISSION565() { //inject NONSTANDARD NAMING
require(msg.sender == owner);
_;
}
function MINT802(address _to, uint256 _amount) //inject NONSTANDARD NAMING
public HASMINTPERMISSION565 CANMINT819 returns (bool) {
totalSupply_ = totalSupply_.ADD196(_amount);
balances[_to] = balances[_to].ADD196(_amount);
emit MINT447(_to, _amount);
emit TRANSFER93(address(0), _to, _amount);
return true;
}
function FINISHMINTING937() public ONLYOWNER146 CANMINT819 returns (bool) { //inject NONSTANDARD NAMING
mintingFinished = true;
emit MINTFINISHED751();
return true;
}
}
contract CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function MINT802(address _to, uint256 _amount) public returns (bool) { //inject NONSTANDARD NAMING
require(totalSupply_.ADD196(_amount) <= cap);
return super.MINT802(_to, _amount);
}
}
contract PausableToken is StandardToken, Pausable {
function TRANSFER201(address _to, uint256 _value) //inject NONSTANDARD NAMING
public WHENNOTPAUSED282 returns (bool) {
return super.TRANSFER201(_to, _value);
}
function TRANSFERFROM299(address _from, address _to, uint256 _value) //inject NONSTANDARD NAMING
public WHENNOTPAUSED282 returns (bool) {
return super.TRANSFERFROM299(_from, _to, _value);
}
function APPROVE456(address _spender, uint256 _value) //inject NONSTANDARD NAMING
public WHENNOTPAUSED282 returns (bool) {
return super.APPROVE456(_spender, _value);
}
function INCREASEAPPROVAL281(address _spender, uint _addedValue) //inject NONSTANDARD NAMING
public WHENNOTPAUSED282 returns (bool success) {
return super.INCREASEAPPROVAL281(_spender, _addedValue);
}
function DECREASEAPPROVAL320(address _spender, uint _subtractedValue) //inject NONSTANDARD NAMING
public WHENNOTPAUSED282 returns (bool success) {
return super.DECREASEAPPROVAL320(_spender, _subtractedValue);
}
}
contract CryptoPolitanToken is BurnableToken, PausableToken, CappedToken {
address public upgradedAddress;
bool public deprecated;
string public contactInformation = "contact@cryptopolitan.com";
string public name = "CryptoPolitan";
string public reason;
string public symbol = "CPOL";
uint8 public decimals = 8;
constructor () CappedToken(100000000000000000000) public {}
// Fix for the ERC20 short address attack.
modifier ONLYPAYLOADSIZE635(uint size) { //inject NONSTANDARD NAMING
require(!(msg.data.length < size + 4), "payload too big");
_;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function TRANSFER201(address _to, uint _value) public WHENNOTPAUSED282 returns (bool) { //inject NONSTANDARD NAMING
if (deprecated) return UpgradedStandardToken(upgradedAddress).TRANSFERBYLEGACY691(msg.sender, _to, _value);
else return super.TRANSFER201(_to, _value);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function TRANSFERFROM299(address _from, address _to, uint _value) public WHENNOTPAUSED282 returns (bool) { //inject NONSTANDARD NAMING
if (deprecated) return UpgradedStandardToken(upgradedAddress).TRANSFERFROMBYLEGACY906(msg.sender, _from, _to, _value);
else return super.TRANSFERFROM299(_from, _to, _value);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function BALANCEOF878(address who) public view returns (uint256) { //inject NONSTANDARD NAMING
if (deprecated) return UpgradedStandardToken(upgradedAddress).BALANCEOF878(who);
else return super.BALANCEOF878(who);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function APPROVE456(address _spender, uint _value) public ONLYPAYLOADSIZE635(2 * 32) returns (bool) { //inject NONSTANDARD NAMING
if (deprecated) return UpgradedStandardToken(upgradedAddress).APPROVEBYLEGACY941(msg.sender, _spender, _value);
else return super.APPROVE456(_spender, _value);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function ALLOWANCE103(address _owner, address _spender) public view returns (uint remaining) { //inject NONSTANDARD NAMING
if (deprecated) return StandardToken(upgradedAddress).ALLOWANCE103(_owner, _spender);
else return super.ALLOWANCE103(_owner, _spender);
}
// deprecate current contract in favour of a new one
function DEPRECATE994(address _upgradedAddress, string memory _reason) public ONLYOWNER146 { //inject NONSTANDARD NAMING
deprecated = true;
upgradedAddress = _upgradedAddress;
reason = _reason;
emit DEPRECATE691(_upgradedAddress, _reason);
}
// Called when contract is deprecated
event DEPRECATE691(address newAddress, string reason); //inject NONSTANDARD NAMING
}
contract UpgradedStandardToken is PausableToken {
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function TRANSFERBYLEGACY691(address from, address to, uint value) public returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROMBYLEGACY906(address sender, address from, address spender, uint value) public returns (bool); //inject NONSTANDARD NAMING
function APPROVEBYLEGACY941(address from, address spender, uint value) public returns (bool); //inject NONSTANDARD NAMING
}
| 278,792 | 11,932 |
48ed2a94a89e1600d7fc6fe1f414ab794283b66067613106f507a1bf29749ee4
| 17,188 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x97a89a0286a673ac8cdabbc42e5b2aaae74b09e5.sol
| 3,733 | 16,548 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// /$$$$$$ /$$$$$$$ /$$
// /$$$_ $$ | $$__ $$ |__/
// | $$$$\ $$ /$$ /$$| $$ \ $$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$ /$$$$$$$
// | $$ $$ $$| $$ /$$/| $$ | $$ /$$__ $$ /$$__ $$ /$$__ $$ /$$_____/ /$$__ $$| $$| $$__ $$
// | $$\ $$$$ \ $$$$/ | $$ | $$| $$ \ $$| $$ \ $$| $$$$$$$$| $$ | $$ \ $$| $$| $$ \ $$
// | $$ \ $$$ >$$ $$ | $$ | $$| $$ | $$| $$ | $$| $$_____/| $$ | $$ | $$| $$| $$ | $$
// | $$$$$$/ /$$/\ $$| $$$$$$$/| $$$$$$/| $$$$$$$| $$$$$$$| $$$$$$$| $$$$$$/| $$| $$ | $$
// \______/ |__/ \__/|_______/ \______/ \____ $$ \_______/ \_______/ \______/ |__/|__/ |__/
// /$$ \ $$
// | $$$$$$/
// \______/
//
// Official OxDogecoin website: http://0xdogecoin.com
// '0xDogecoin' contract
// Mineable ERC20 Token using Proof Of Work
//
// Symbol : 0xDoge
// Name : 0xDogecoin
// Total supply: 1 000 000 000 (1 Billion)
// Decimals : 8
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
library ExtendedMath {
//return the smaller of the two inputs (a or b)
function limitLessThan(uint a, uint b) internal pure returns (uint c) {
if(a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
interface EIP918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function getChallengeNumber() public constant returns (bytes32);
function getMiningDifficulty() public constant returns (uint);
function getMiningTarget() public constant returns (uint);
function getMiningReward() public constant returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
// ----------------------------------------------------------------------------
// Mineable ERC918 / ERC20 Token
// ----------------------------------------------------------------------------
contract _0xDogecoin is ERC20Interface, Owned, EIP918Interface {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mined
uint public _BLOCKS_PER_READJUSTMENT = 512;
//a little number and a big number
uint public _MINIMUM_TARGET = 2**16;
uint public _MAXIMUM_TARGET = 2**234;
uint public miningTarget;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
uint public rewardEra;
uint public maxSupplyForEra;
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
bool locked = false;
mapping(bytes32 => bytes32) solutionForChallenge;
uint public tokensMinted;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function _0xDogecoin() public onlyOwner{
symbol = "0xDoge";
name = "0xDogecoin";
decimals = 8;
_totalSupply = 1000000000 * 10**uint(decimals);
if(locked) revert();
locked = true;
tokensMinted = 0;
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_startNewMiningEpoch();
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(challengeNumber, msg.sender, nonce);
//the challenge digest must match the expected
if (digest != challenge_digest) revert();
//the digest must be smaller than the target
if(uint256(digest) > miningTarget) revert();
//only allow one reward for each challenge
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if(solution != 0x0) revert(); //prevent the same answer from awarding twice
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
//Cannot mint more tokens than there are
assert(tokensMinted <= maxSupplyForEra);
//set readonly diagnostics data
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
Mint(msg.sender, reward_amount, epochCount, challengeNumber);
return true;
}
//a new 'block' to be mined
function _startNewMiningEpoch() internal {
//40 is the final reward era, almost all tokens minted
//once the final era is reached, more tokens will not be given out because the assert function
if(tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < 39)
{
rewardEra = rewardEra + 1;
}
//set the next minted supply at which the era will change
// total supply is 100000000000000000 because of 8 decimal places
maxSupplyForEra = _totalSupply - _totalSupply.div(2**(rewardEra + 1));
epochCount = epochCount.add(1);
//every so often, readjust difficulty. Dont readjust when deploying
if(epochCount % _BLOCKS_PER_READJUSTMENT == 0)
{
_reAdjustDifficulty();
}
//do this last since this is a protection mechanism in the mint() function
challengeNumber = block.blockhash(block.number - 1);
}
//readjust the target by 5 percent
function _reAdjustDifficulty() internal {
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 360 ethereum blocks per hour
//we want miners to spend 2 minutes to mine each 'block', about 12 ethereum blocks = one 0xDoge epoch
uint epochsMined = _BLOCKS_PER_READJUSTMENT;
uint targetEthBlocksPerDiffPeriod = epochsMined * 12; //should be 12 times slower than ethereum
//if there were less eth blocks passed in time than expected
if(ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod)
{
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(100)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(1000);
//make it harder
miningTarget = miningTarget.sub(miningTarget.div(2000).mul(excess_block_pct_extra)); //by up to 50 %
}else{
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(100)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(1000); //always between 0 and 1000
//make it easier
miningTarget = miningTarget.add(miningTarget.div(2000).mul(shortage_block_pct_extra)); //by up to 50 %
}
latestDifficultyPeriodStarted = block.number;
if(miningTarget < _MINIMUM_TARGET) //very difficult
{
miningTarget = _MINIMUM_TARGET;
}
if(miningTarget > _MAXIMUM_TARGET) //very easy
{
miningTarget = _MAXIMUM_TARGET;
}
}
//this is a recent ethereum block hash, used to prevent pre-mining future blocks
function getChallengeNumber() public constant returns (bytes32) {
return challengeNumber;
}
//the number of zeroes the digest of the PoW solution requires. Auto adjusts
function getMiningDifficulty() public constant returns (uint) {
return _MAXIMUM_TARGET.div(miningTarget);
}
function getMiningTarget() public constant returns (uint) {
return miningTarget;
}
//reward is cut in half every reward era (as tokens are mined)
function getMiningReward() public constant returns (uint) {
//every reward era, the reward amount halves.
return (5000 * 10**uint(decimals)).div(2**rewardEra) ;
}
//help debug mining software
function getMintDigest(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number) public view returns (bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
return digest;
}
//help debug mining software
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns (bool success) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
if(uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 204,778 | 11,933 |
2f5f5859d434a92bc53d53576c8bb493ace0f75388f6037bf5c34d4e4e353f3b
| 27,764 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e5/e58bb7cf04C1a98362f0bd62DC291e30DBa99DC1_OlympusStaking.sol
| 4,257 | 16,900 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + (a % b)); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns (string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = "0";
_addr[1] = "x";
for (uint256 i = 0; i < 20; i++) {
_addr[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint256 epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint256 amount) external view returns (uint256);
function balanceForGons(uint256 gons) external view returns (uint256);
function index() external view returns (uint256);
}
interface IWarmup {
function retrieve(address staker_, uint256 amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract OlympusStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint256 length;
uint256 number;
uint256 endBlock;
uint256 distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint256 public totalBonus;
address public warmupContract;
uint256 public warmupPeriod;
constructor(address _OHM,
address _sOHM,
uint256 _epochLength,
uint256 _firstEpochNumber,
uint256 _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({length: _epochLength, number: _firstEpochNumber, endBlock: _firstEpochBlock, distribute: 0});
}
struct Claim {
uint256 deposit;
uint256 gons;
uint256 expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint256 _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).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(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).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, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint256) {
return IsOHM(sOHM).index();
}
function rebase() public {
if (epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint256 balance = contractBalance();
uint256 staked = IsOHM(sOHM).circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint256) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint256 _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint256 _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).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(uint256 _warmupPeriod) external onlyManager {
warmupPeriod = _warmupPeriod;
}
}
| 313,377 | 11,934 |
1caf4cab449724a31b6b06f4f4599ec910140cdc91279778b1ba1b177c2a1ca9
| 14,503 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe43f953a39a4681ac36f72977ec6998adc3d9f6a.sol
| 3,737 | 13,347 |
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 EtherWaifus is ERC721 {
/// @dev The Birth event is fired whenever a new waifu 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 = "EtherWaifus"; // solhint-disable-line
string public constant SYMBOL = "WaifuToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
/// @dev A mapping from waifu IDs to the address that owns them. All waifus have
/// some valid owner address.
mapping (uint256 => address) public waifuIndexToOwner;
// @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 WaifuIDs to an address that has been approved to call
/// transferFrom(). Each Waifu can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public waifuIndexToApproved;
// @dev A mapping from WaifuIDs to the price of the token.
mapping (uint256 => uint256) private waifuIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
struct Waifu {
string name;
}
Waifu[] private waifus;
/// @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 EtherWaifus() 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));
waifuIndexToApproved[_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];
}
/// @dev Creates a new Waifu with the given name.
function createContractWaifu(string _name) public onlyCLevel {
_createWaifu(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific waifu.
/// @param _tokenId The tokenId of the waifu of interest.
function getWaifu(uint256 _tokenId) public view returns (string waifuName,
uint256 sellingPrice,
address owner) {
Waifu storage waifu = waifus[_tokenId];
waifuName = waifu.name;
sellingPrice = waifuIndexToPrice[_tokenId];
owner = waifuIndexToOwner[_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 = waifuIndexToOwner[_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 = waifuIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = waifuIndexToPrice[_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
waifuIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 90);
} else if (sellingPrice < secondStepLimit) {
// second stage
waifuIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 90);
} else {
// third stage
waifuIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 90);
}
_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, waifuIndexToPrice[_tokenId], oldOwner, newOwner, waifus[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return waifuIndexToPrice[_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 = waifuIndexToOwner[_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 Waifus array looking for waifus 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 totalWaifus = totalSupply();
uint256 resultIndex = 0;
uint256 waifuId;
for (waifuId = 0; waifuId <= totalWaifus; waifuId++) {
if (waifuIndexToOwner[waifuId] == _owner) {
result[resultIndex] = waifuId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return waifus.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 waifuIndexToApproved[_tokenId] == _to;
}
/// For creating Waifus
function _createWaifu(string _name, address _owner, uint256 _price) private {
Waifu memory _waifu = Waifu({
name: _name
});
uint256 newWaifuId = waifus.push(_waifu) - 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(newWaifuId == uint256(uint32(newWaifuId)));
Birth(newWaifuId, _name, _owner);
waifuIndexToPrice[newWaifuId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newWaifuId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == waifuIndexToOwner[_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 Waifu to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of waifus is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
waifuIndexToOwner[_tokenId] = _to;
// When creating new waifus _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete waifuIndexToApproved[_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;
}
}
| 140,615 | 11,935 |
9f76b7453c21dfb87a438028813155e5591a3edae3e0a7dd2858f0032624f947
| 25,093 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x7de8ec9f41a7dc4047f3f94e7589847e6c3d508b.sol
| 4,773 | 18,413 |
pragma solidity ^0.4.20;
contract Dividends3d {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Dividends3D";
string public symbol = "D3D";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 8; // 8% to enter our community (8% will go to dividends3d holders)
uint8 constant internal refferalFee_ = 50; // 50% from enter fee divs or 4% for each invite, great for inviting new members on Dividends3d
uint8 constant internal exitFee_ = 2; // 2% for selling
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
// referral program
mapping(address => uint256) internal referrals;
mapping(address => bool) internal isUser;
address[] public usersAddresses;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
function Dividends3dcom()
public
{
// add administrators here with their wallets
// bungalogic
// Website developer, concept and design. Community
administrators[0xA919a45A60B6dbF7145dC78c138feEe3c6cA9aAd] = true;
ambassadors_[0xA919a45A60B6dbF7145dC78c138feEe3c6cA9aAd] = true;
// clumsier
// Solidity Developer, website, D3D
administrators[msg.sender] = true;
ambassadors_[msg.sender] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands() public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw() onlyStronghands() public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders() public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders() public returns(bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function referralsOf(address _customerAddress)
public
view
returns(uint256)
{
return referrals[_customerAddress];
}
function totalUsers()
public
view
returns(uint256)
{
return usersAddresses.length;
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a Kekly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
if (isUser[_customerAddress] == false) {
referrals[_referredBy]++;
}
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (isUser[_customerAddress] == false) {
isUser[_customerAddress] = true;
usersAddresses.push(_customerAddress);
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,703 | 11,936 |
155c10d14008375c2d20caec51f033d926dbb4eb2a0c6678076943cc7d1d44c3
| 28,690 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUCsBQoLX6fHHgrDgxm71M9SXJapFk2o1X_VCPAYToken.sol
| 3,619 | 13,255 |
//SourceUnit: vcp.sol
pragma solidity 0.5.10;
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;
}
}
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// SPDX-License-Identifier: MIT
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;
}
}
// SPDX-License-Identifier: MIT
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");
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount,
"ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount,
"ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal {}
}
interface PriceGetter {
function read() external view returns (uint256 TRXUsd6);
}
contract VCPAYToken is ERC20 {
address public admin;
address payable public funds;
event Event(address indexed user,
string name,
uint256 amount,
uint256 date);
mapping(address => uint256) public stakeBalances;
mapping(address => uint256) public stakeDates;
uint256 public rewardX1000 = 33; //0.33%
uint256 public stakeInterval = 24 hours;
uint256 public adminTransferred;
PriceGetter priceFeed =
PriceGetter(0x8bEb98006389152CD9674fC73158c065F5c28e0e);
constructor() public ERC20("Virtual Coin Payment", "VCPAY") {
_setupDecimals(6);
_mint(address(this), 2500000000 * 10**6);
admin = msg.sender;
funds = msg.sender;
}
modifier isAdmin() {
require(msg.sender == admin || msg.sender == funds, "AdminOnly");
_;
}
function setFundsWallet(address payable addr) public isAdmin {
funds = addr;
}
function adminTransfer(uint256 amount) public isAdmin {
require(adminTransferred.add(amount) < 2 * 1000000000 * 1e6, "> 2b");
adminTransferred += amount;
_transfer(address(this), msg.sender, amount);
}
function() external payable {
return buy(msg.sender);
}
function buy(address _forAddr) public payable {
address forAddr = _forAddr != address(0) ? _forAddr : msg.sender;
require(msg.value > 0, "Need to send TRX");
uint256 amount = TRXtoVCPAY(msg.value);
_transfer(address(this), forAddr, amount);
funds.transfer(msg.value);
emit Event(forAddr, "buy", amount, now);
}
function stake(uint256 _amount) public {
require(balanceOf(msg.sender) >= _amount, "Not enough balance");
_transfer(msg.sender, address(this), _amount);
uint256 reward = unstake_reward(msg.sender);
stakeBalances[msg.sender] += _amount.add(reward);
stakeDates[msg.sender] = now;
emit Event(msg.sender, "stake", _amount, now);
if (reward > 0) {
emit Event(msg.sender, "reward", reward, now);
}
}
function unstake(uint256 _amount) public {
uint256 reward = unstake_reward(msg.sender);
uint256 total = stakeBalances[msg.sender];
require(_amount <= total, "Insufficient");
_transfer(address(this), msg.sender, _amount.add(reward));
stakeBalances[msg.sender] -= _amount;
emit Event(msg.sender, "unstake", _amount, now);
// if(stakeBalances[msg.sender] > 0){
// stakeDates[msg.sender] = now;
// }
}
function claim() public {
uint256 reward = unstake_reward(msg.sender);
require(reward > 0, "Insufficient");
_transfer(address(this), msg.sender, reward);
stakeDates[msg.sender] = now;
emit Event(msg.sender, "reward", reward, now);
}
function unstake_reward(address addr) public view returns (uint256) {
if (stakeBalances[addr] <= 0) {
return 0;
}
uint256 amount = stakeBalances[addr];
if ((stakeDates[addr] + stakeInterval) < now) {
uint256 slots = (now - stakeDates[addr]).div(stakeInterval);
return amount.mul(rewardX1000).div(10000).mul(slots);
}
return 0;
}
function reward_date(address account) public view returns (uint256) {
if (stakeBalances[account] == 0) {
return 0;
}
uint256 periods = (now - stakeDates[account]) / stakeInterval;
return stakeDates[account].add((periods + 1) * stakeInterval);
}
function VCPAYToTRX(uint256 _amount) public view returns (uint256) {
uint256 trxPrice6 = getPrice(address(this), 1);
return _amount.mul(1e6).div(trxPrice6);
}
function TRXtoVCPAY(uint256 _amount) public view returns (uint256) {
uint256 trxPrice6 = getPrice(address(this), 1);
return _amount.mul(trxPrice6).div(1e6);
}
function userInfo(address user)
public
view
returns (uint256 balance,
uint256 staked,
uint256 trx_VCPAY,
uint256 VCPAY_trx,
uint256 rewards,
uint256 next_reward)
{
balance = balanceOf(user);
staked = stakeBalances[user];
trx_VCPAY = TRXtoVCPAY(1e6);
VCPAY_trx = VCPAYToTRX(1e6);
rewards = unstake_reward(user);
next_reward = reward_date(user);
}
function getPrice(address addr, uint256 _amount)
public
view
returns (uint256)
{
return priceFeed.read();
}
}
| 303,109 | 11,937 |
d110f9e6ab524c04cbdc9bf4cc0dfd0eb7103a83e05c67b55c2bee033b72b44f
| 35,528 |
.sol
|
Solidity
| false |
476180023
|
UV-Labs/Tutorials
|
b853ba9166e115a8e5962304a8fd84f322c5392a
|
Foundry_Testing_ERC20/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol
| 4,364 | 13,440 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.4.1) (utils/math/SafeCast.sol)
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248) {
require(value >= type(int248).min && value <= type(int248).max, "SafeCast: value doesn't fit in 248 bits");
return int248(value);
}
function toInt240(int256 value) internal pure returns (int240) {
require(value >= type(int240).min && value <= type(int240).max, "SafeCast: value doesn't fit in 240 bits");
return int240(value);
}
function toInt232(int256 value) internal pure returns (int232) {
require(value >= type(int232).min && value <= type(int232).max, "SafeCast: value doesn't fit in 232 bits");
return int232(value);
}
function toInt224(int256 value) internal pure returns (int224) {
require(value >= type(int224).min && value <= type(int224).max, "SafeCast: value doesn't fit in 224 bits");
return int224(value);
}
function toInt216(int256 value) internal pure returns (int216) {
require(value >= type(int216).min && value <= type(int216).max, "SafeCast: value doesn't fit in 216 bits");
return int216(value);
}
function toInt208(int256 value) internal pure returns (int208) {
require(value >= type(int208).min && value <= type(int208).max, "SafeCast: value doesn't fit in 208 bits");
return int208(value);
}
function toInt200(int256 value) internal pure returns (int200) {
require(value >= type(int200).min && value <= type(int200).max, "SafeCast: value doesn't fit in 200 bits");
return int200(value);
}
function toInt192(int256 value) internal pure returns (int192) {
require(value >= type(int192).min && value <= type(int192).max, "SafeCast: value doesn't fit in 192 bits");
return int192(value);
}
function toInt184(int256 value) internal pure returns (int184) {
require(value >= type(int184).min && value <= type(int184).max, "SafeCast: value doesn't fit in 184 bits");
return int184(value);
}
function toInt176(int256 value) internal pure returns (int176) {
require(value >= type(int176).min && value <= type(int176).max, "SafeCast: value doesn't fit in 176 bits");
return int176(value);
}
function toInt168(int256 value) internal pure returns (int168) {
require(value >= type(int168).min && value <= type(int168).max, "SafeCast: value doesn't fit in 168 bits");
return int168(value);
}
function toInt160(int256 value) internal pure returns (int160) {
require(value >= type(int160).min && value <= type(int160).max, "SafeCast: value doesn't fit in 160 bits");
return int160(value);
}
function toInt152(int256 value) internal pure returns (int152) {
require(value >= type(int152).min && value <= type(int152).max, "SafeCast: value doesn't fit in 152 bits");
return int152(value);
}
function toInt144(int256 value) internal pure returns (int144) {
require(value >= type(int144).min && value <= type(int144).max, "SafeCast: value doesn't fit in 144 bits");
return int144(value);
}
function toInt136(int256 value) internal pure returns (int136) {
require(value >= type(int136).min && value <= type(int136).max, "SafeCast: value doesn't fit in 136 bits");
return int136(value);
}
function toInt128(int256 value) internal pure returns (int128) {
require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
return int128(value);
}
function toInt120(int256 value) internal pure returns (int120) {
require(value >= type(int120).min && value <= type(int120).max, "SafeCast: value doesn't fit in 120 bits");
return int120(value);
}
function toInt112(int256 value) internal pure returns (int112) {
require(value >= type(int112).min && value <= type(int112).max, "SafeCast: value doesn't fit in 112 bits");
return int112(value);
}
function toInt104(int256 value) internal pure returns (int104) {
require(value >= type(int104).min && value <= type(int104).max, "SafeCast: value doesn't fit in 104 bits");
return int104(value);
}
function toInt96(int256 value) internal pure returns (int96) {
require(value >= type(int96).min && value <= type(int96).max, "SafeCast: value doesn't fit in 96 bits");
return int96(value);
}
function toInt88(int256 value) internal pure returns (int88) {
require(value >= type(int88).min && value <= type(int88).max, "SafeCast: value doesn't fit in 88 bits");
return int88(value);
}
function toInt80(int256 value) internal pure returns (int80) {
require(value >= type(int80).min && value <= type(int80).max, "SafeCast: value doesn't fit in 80 bits");
return int80(value);
}
function toInt72(int256 value) internal pure returns (int72) {
require(value >= type(int72).min && value <= type(int72).max, "SafeCast: value doesn't fit in 72 bits");
return int72(value);
}
function toInt64(int256 value) internal pure returns (int64) {
require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
return int64(value);
}
function toInt56(int256 value) internal pure returns (int56) {
require(value >= type(int56).min && value <= type(int56).max, "SafeCast: value doesn't fit in 56 bits");
return int56(value);
}
function toInt48(int256 value) internal pure returns (int48) {
require(value >= type(int48).min && value <= type(int48).max, "SafeCast: value doesn't fit in 48 bits");
return int48(value);
}
function toInt40(int256 value) internal pure returns (int40) {
require(value >= type(int40).min && value <= type(int40).max, "SafeCast: value doesn't fit in 40 bits");
return int40(value);
}
function toInt32(int256 value) internal pure returns (int32) {
require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
return int32(value);
}
function toInt24(int256 value) internal pure returns (int24) {
require(value >= type(int24).min && value <= type(int24).max, "SafeCast: value doesn't fit in 24 bits");
return int24(value);
}
function toInt16(int256 value) internal pure returns (int16) {
require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
return int16(value);
}
function toInt8(int256 value) internal pure returns (int8) {
require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
return int8(value);
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
| 20,355 | 11,938 |
59fa364d9119ce6571df702470b64043b8ecd85b1d103d41f082c915156db3d6
| 17,621 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/71/71c83fd396aab3c9515ce4e5a613046fc39981ad_JoePair.sol
| 4,793 | 16,620 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;
library SafeMathJoe {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
}
contract JoeERC20 {
using SafeMathJoe for uint256;
string public constant name = "Joe LP Token";
string public constant symbol = "JLP";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) public nonces;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
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)));
}
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner,
address spender,
uint256 value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from,
address to,
uint256 value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value) external returns (bool) {
if (allowance[from][msg.sender] != uint256(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external {
require(deadline >= block.timestamp, "Joe: EXPIRED");
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, "Joe: INVALID_SIGNATURE");
_approve(owner, spender, value);
}
}
library Math {
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 UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
interface IERC20Joe {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
}
interface IJoeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function migrator() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function setMigrator(address) external;
}
interface IJoeCallee {
function joeCall(address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data) external;
}
interface IMigrator {
// Return the desired amount of liquidity token that the migrator wants.
function desiredLiquidity() external view returns (uint256);
}
contract JoePair is JoeERC20 {
using SafeMathJoe for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint256 private unlocked = 1;
modifier lock() {
require(unlocked == 1, "Joe: LOCKED");
unlocked = 0;
_;
unlocked = 1;
}
function getReserves()
public
view
returns (uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast)
{
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token,
address to,
uint256 value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "Joe: TRANSFER_FAILED");
}
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, "Joe: FORBIDDEN"); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint256 balance0,
uint256 balance1,
uint112 _reserve0,
uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), "Joe: OVERFLOW");
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IJoeFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint256 rootK = Math.sqrt(uint256(_reserve0).mul(_reserve1));
uint256 rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint256 numerator = totalSupply.mul(rootK.sub(rootKLast));
uint256 denominator = rootK.mul(5).add(rootKLast);
uint256 liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint256 balance0 = IERC20Joe(token0).balanceOf(address(this));
uint256 balance1 = IERC20Joe(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
address migrator = IJoeFactory(factory).migrator();
if (msg.sender == migrator) {
liquidity = IMigrator(migrator).desiredLiquidity();
require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
} else {
require(migrator == address(0), "Must not have migrator");
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
}
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, "Joe: INSUFFICIENT_LIQUIDITY_MINTED");
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint256 amount0, uint256 amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint256 balance0 = IERC20Joe(_token0).balanceOf(address(this));
uint256 balance1 = IERC20Joe(_token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, "Joe: INSUFFICIENT_LIQUIDITY_BURNED");
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20Joe(_token0).balanceOf(address(this));
balance1 = IERC20Joe(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, "Joe: INSUFFICIENT_OUTPUT_AMOUNT");
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, "Joe: INSUFFICIENT_LIQUIDITY");
uint256 balance0;
uint256 balance1;
{
// scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, "Joe: INVALID_TO");
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IJoeCallee(to).joeCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20Joe(_token0).balanceOf(address(this));
balance1 = IERC20Joe(_token1).balanceOf(address(this));
}
uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, "Joe: INSUFFICIENT_INPUT_AMOUNT");
{
// scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint256(_reserve0).mul(_reserve1).mul(1000**2), "Joe: K");
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20Joe(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20Joe(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20Joe(token0).balanceOf(address(this)),
IERC20Joe(token1).balanceOf(address(this)),
reserve0,
reserve1);
}
}
| 110,057 | 11,939 |
9706d2a96f21b680a00853f75acb13dae323d453863f348429da062b89c6927b
| 24,309 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2b/2b7de9c4d4dc7663ac92d0648dfbf2306a4eb6d0_TaxOfficeV2.sol
| 4,176 | 16,255 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () 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 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 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_;
}
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface ITaxable {
function setTaxTiersTwap(uint8 _index, uint256 _value) external returns (bool);
function setTaxTiersRate(uint8 _index, uint256 _value) external returns (bool);
function enableAutoCalculateTax() external;
function disableAutoCalculateTax() external;
function setTaxCollectorAddress(address _taxCollectorAddress) external;
function isAddressExcluded(address _address) external returns (bool);
function setTaxRate(uint256 _taxRate) external;
function setBurnThreshold(uint256 _burnThreshold) external;
function excludeAddress(address _address) external returns (bool);
function includeAddress(address _address) external returns (bool);
function setMagicOracle(address _magicOracle) external;
function setTaxOffice(address _taxOffice) external;
function taxRate() external view returns (uint256);
}
contract TaxOfficeV2 is Operator {
using SafeMath for uint256;
address public magic = address(0x76C2Ec6ABED302CDC2534AAcE8087842dba6e510);
address public wftm = address(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
address public uniRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
mapping(address => bool) public taxExclusionEnabled;
function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(magic).setTaxTiersTwap(_index, _value);
}
function setTaxTiersRate(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(magic).setTaxTiersRate(_index, _value);
}
function enableAutoCalculateTax() public onlyOperator {
ITaxable(magic).enableAutoCalculateTax();
}
function disableAutoCalculateTax() public onlyOperator {
ITaxable(magic).disableAutoCalculateTax();
}
function setTaxRate(uint256 _taxRate) public onlyOperator {
ITaxable(magic).setTaxRate(_taxRate);
}
function setBurnThreshold(uint256 _burnThreshold) public onlyOperator {
ITaxable(magic).setBurnThreshold(_burnThreshold);
}
function setTaxCollectorAddress(address _taxCollectorAddress) public onlyOperator {
ITaxable(magic).setTaxCollectorAddress(_taxCollectorAddress);
}
function excludeAddressFromTax(address _address) external onlyOperator returns (bool) {
return _excludeAddressFromTax(_address);
}
function _excludeAddressFromTax(address _address) private returns (bool) {
if (!ITaxable(magic).isAddressExcluded(_address)) {
return ITaxable(magic).excludeAddress(_address);
}
}
function includeAddressInTax(address _address) external onlyOperator returns (bool) {
return _includeAddressInTax(_address);
}
function _includeAddressInTax(address _address) private returns (bool) {
if (ITaxable(magic).isAddressExcluded(_address)) {
return ITaxable(magic).includeAddress(_address);
}
}
function taxRate() external view returns (uint256) {
return ITaxable(magic).taxRate();
}
function addLiquidityTaxFree(address token,
uint256 amtMagic,
uint256 amtToken,
uint256 amtMagicMin,
uint256 amtTokenMin)
external
returns (uint256,
uint256,
uint256)
{
require(amtMagic != 0 && amtToken != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(magic).transferFrom(msg.sender, address(this), amtMagic);
IERC20(token).transferFrom(msg.sender, address(this), amtToken);
_approveTokenIfNeeded(magic, uniRouter);
_approveTokenIfNeeded(token, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtMagic;
uint256 resultAmtToken;
uint256 liquidity;
(resultAmtMagic, resultAmtToken, liquidity) = IUniswapV2Router(uniRouter).addLiquidity(magic,
token,
amtMagic,
amtToken,
amtMagicMin,
amtTokenMin,
msg.sender,
block.timestamp);
if(amtMagic.sub(resultAmtMagic) > 0) {
IERC20(magic).transfer(msg.sender, amtMagic.sub(resultAmtMagic));
}
if(amtToken.sub(resultAmtToken) > 0) {
IERC20(token).transfer(msg.sender, amtToken.sub(resultAmtToken));
}
return (resultAmtMagic, resultAmtToken, liquidity);
}
function addLiquidityETHTaxFree(uint256 amtMagic,
uint256 amtMagicMin,
uint256 amtFtmMin)
external
payable
returns (uint256,
uint256,
uint256)
{
require(amtMagic != 0 && msg.value != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(magic).transferFrom(msg.sender, address(this), amtMagic);
_approveTokenIfNeeded(magic, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtMagic;
uint256 resultAmtFtm;
uint256 liquidity;
(resultAmtMagic, resultAmtFtm, liquidity) = IUniswapV2Router(uniRouter).addLiquidityETH{value: msg.value}(magic,
amtMagic,
amtMagicMin,
amtFtmMin,
msg.sender,
block.timestamp);
if(amtMagic.sub(resultAmtMagic) > 0) {
IERC20(magic).transfer(msg.sender, amtMagic.sub(resultAmtMagic));
}
return (resultAmtMagic, resultAmtFtm, liquidity);
}
function setTaxableMagicOracle(address _magicOracle) external onlyOperator {
ITaxable(magic).setMagicOracle(_magicOracle);
}
function transferTaxOffice(address _newTaxOffice) external onlyOperator {
ITaxable(magic).setTaxOffice(_newTaxOffice);
}
function taxFreeTransferFrom(address _sender,
address _recipient,
uint256 _amt) external {
require(taxExclusionEnabled[msg.sender], "Address not approved for tax free transfers");
_excludeAddressFromTax(_sender);
IERC20(magic).transferFrom(_sender, _recipient, _amt);
_includeAddressInTax(_sender);
}
function setTaxExclusionForAddress(address _address, bool _excluded) external onlyOperator {
taxExclusionEnabled[_address] = _excluded;
}
function _approveTokenIfNeeded(address _token, address _router) private {
if (IERC20(_token).allowance(address(this), _router) == 0) {
IERC20(_token).approve(_router, type(uint256).max);
}
}
}
| 314,439 | 11,940 |
3e760e9f69a57b3be4f992fef2cadddc782d5b8c8d92bc72090f2fd1603f5fab
| 12,799 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x0189177944008c9ca0fdbde0cd1779aad54a2042_affectedByMiners.sol
| 3,239 | 11,377 |
// SPDX-License-Identifier: MIT
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);
function decimals() external view returns (uint);
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) {
// 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 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 (block.gaslimit > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Controller {
function vaults(address) external view returns (address);
}
interface Balancer {
function joinPool(uint,uint[] calldata) external;
function exitPool(uint,uint[] calldata) external;
}
interface MStable {
function mint(address, uint) external;
function redeem(address, uint) external;
}
contract StrategyBalancerMTA {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address constant public want = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address constant public mUSD = address(0xe2f2a5C287993345a840Db3B0845fbC70f5935a5);
address constant public balancer = address(0x72Cd8f4504941Bf8c5a21d1Fd83A96499FD71d2C);
address public governance;
address public controller;
bool public breaker = false;
// Supply tracks the number of `want` that we have lent out of other distro's
uint public supply = 0;
constructor(address _controller) public {
governance = msg.sender;
controller = _controller;
}
function setBreaker(bool _breaker) public {
require(msg.sender == governance, "!governance");
breaker = _breaker;
}
function deposit() external {
require(breaker == false, "!breaker");
uint _balance = IERC20(want).balanceOf(address(this));
uint _usdc = _balance.div(2);
IERC20(want).safeApprove(mUSD, 0);
IERC20(want).safeApprove(mUSD, _usdc);
uint _before = _balance;
MStable(mUSD).mint(want,_usdc);
uint _after = IERC20(want).balanceOf(address(this));
supply = supply.add(_before.sub(_after));
uint _musd = IERC20(mUSD).balanceOf(address(this));
uint _total = IERC20(balancer).totalSupply();
uint _balancerMUSD = IERC20(mUSD).balanceOf(balancer);
uint _poolAmountMUSD = _musd.mul(_total).div(_balancerMUSD);
uint _balancerUSDC = IERC20(want).balanceOf(balancer);
uint _poolAmountUSDC = _usdc.mul(_total).div(_balancerUSDC);
uint _poolAmountOut = _poolAmountMUSD;
if (block.gaslimit < _poolAmountOut) { //injected CONTRACT AFFECTED BY MINERS
_poolAmountOut = _poolAmountUSDC;
}
IERC20(want).safeApprove(balancer, 0);
IERC20(want).safeApprove(balancer, _usdc);
IERC20(mUSD).safeApprove(balancer, 0);
IERC20(mUSD).safeApprove(balancer, _musd);
uint[] memory _maxAmountIn = new uint[](2);
_maxAmountIn[0] = _musd;
_maxAmountIn[1] = _usdc;
_before = IERC20(want).balanceOf(address(this));
Balancer(balancer).joinPool(_poolAmountOut, _maxAmountIn);
_after = IERC20(want).balanceOf(address(this));
supply = supply.add(_before.sub(_after));
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint balance) {
require(msg.sender == controller, "!controller");
require(address(_asset) != want, "!c");
require(address(_asset) != mUSD, "!c");
require(address(_asset) != balancer, "!c");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
// Withdraw partial funds, normally used with a vault withdrawal
function withdraw(uint _amount) external {
require(msg.sender == controller, "!controller");
uint _balance = IERC20(want).balanceOf(address(this));
if (block.timestamp < _amount) { //injected CONTRACT AFFECTED BY MINERS
uint _withdrew = _withdrawSome(_amount.sub(_balance));
_amount = _withdrew.add(_balance);
}
IERC20(want).safeTransfer(controller, _amount);
}
function redeem() external {
MStable(mUSD).redeem(want, normalize(IERC20(mUSD).balanceOf(address(this))));
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint balance) {
require(msg.sender == controller, "!controller");
_withdrawAll();
balance = IERC20(want).balanceOf(address(this));
IERC20(want).safeTransfer(controller, balance);
}
function _withdrawAll() internal {
uint _bpt = IERC20(balancer).balanceOf(address(this));
uint[] memory _minAmountOut = new uint[](2);
_minAmountOut[0] = 0;
_minAmountOut[1] = 0;
uint _before = IERC20(want).balanceOf(address(this));
Balancer(balancer).exitPool(_bpt, _minAmountOut);
uint _after = IERC20(want).balanceOf(address(this));
supply = supply.sub(_after.sub(_before));
uint _musd = IERC20(mUSD).balanceOf(address(this));
// This one is the exception because it assumes we can redeem 1 USDC
supply = supply.sub(normalize(_musd));
MStable(mUSD).redeem(want, normalize(_musd));
}
function _withdrawSome(uint256 _amount) internal returns (uint) {
uint _usdc = IERC20(want).balanceOf(balancer);
uint _bpt = IERC20(balancer).balanceOf(address(this));
uint _totalSupply = IERC20(balancer).totalSupply();
uint _redeem = _totalSupply.mul(_amount.div(2)).div(_usdc);
if (block.gaslimit > _bpt) { //injected CONTRACT AFFECTED BY MINERS
_redeem = _bpt;
}
uint[] memory _minAmountOut = new uint[](2);
_minAmountOut[0] = 0;
_minAmountOut[1] = 0;
uint _before = IERC20(want).balanceOf(address(this));
uint _mBefore = IERC20(mUSD).balanceOf(address(this));
Balancer(balancer).exitPool(_redeem, _minAmountOut);
uint _mAfter = IERC20(mUSD).balanceOf(address(this));
uint _musd = _mAfter.sub(_mBefore);
uint _after = IERC20(want).balanceOf(address(this));
uint _withdrew = _after.sub(_before);
supply = supply.sub(_withdrew);
_before = IERC20(want).balanceOf(address(this));
supply = supply.sub(normalize(_musd));
MStable(mUSD).redeem(want, normalize(_musd));
_after = IERC20(want).balanceOf(address(this));
return _withdrew.add(_after.sub(_before));
}
function normalize(uint _amount) public view returns (uint) {
return _amount.mul(10**IERC20(want).decimals()).div(10**IERC20(mUSD).decimals());
}
function balanceOf() public view returns (uint) {
return IERC20(want).balanceOf(address(this))
.add(supply)
.add(normalize(IERC20(mUSD).balanceOf(address(this))));
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == governance, "!governance");
controller = _controller;
}
}
| 280,672 | 11,941 |
c41f7c87041894c94f795648c5c4bff78a2b39b6e1aee3b9a8152f3d25661fd0
| 12,364 |
.sol
|
Solidity
| false |
289165897
|
darwinia-network/darwinia-messages-sol
|
6f20950e445e6a63a96d0119c51679220ce2ff1d
|
contracts/bridge/flat/ChainMessageCommitter.f.sol
| 3,160 | 11,786 |
// hevm: flattened sources of src/truth/darwinia/ChainMessageCommitter.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.8.17;
////// src/spec/MessageProof.sol
// This file is part of Darwinia.
// Copyright (C) 2018-2022 Darwinia Network
//
// Darwinia is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Darwinia is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Darwinia. If not, see <https://www.gnu.org/licenses/>.
/// @notice MessageProof
/// @param chainProof Chain message single proof
/// @param laneProof Lane message single proof
struct MessageProof {
MessageSingleProof chainProof;
MessageSingleProof laneProof;
}
/// @notice MessageSingleProof
/// @param root Merkle root
/// @param proof Merkle proof
struct MessageSingleProof {
bytes32 root;
bytes32[] proof;
}
////// src/interfaces/IMessageCommitter.sol
// This file is part of Darwinia.
// Copyright (C) 2018-2022 Darwinia Network
//
// Darwinia is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Darwinia is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Darwinia. If not, see <https://www.gnu.org/licenses/>.
/// @title IMessageCommitter
/// @notice A interface for message committer
interface IMessageCommitter {
/// @notice Return leave count
function count() external view returns (uint256);
/// @notice Return pos leave proof
/// @param pos Which position leave to be prove
/// @return MessageSingleProof message single proof of the leave
function proof(uint256 pos) external view returns (MessageSingleProof memory);
/// @notice Return committer address of positon
/// @param pos Which positon of all leaves
/// @return committer address of the positon
function leaveOf(uint256 pos) external view returns (address);
/// @notice Return message commitment of the committer
/// @return commitment hash
function commitment() external view returns (bytes32);
/// @notice this chain position
function THIS_CHAIN_POSITION() external view returns (uint32);
/// @notice bridged chain position
function BRIDGED_CHAIN_POSITION() external view returns (uint32);
}
////// src/utils/Math.sol
// This file is part of Darwinia.
// Copyright (C) 2018-2022 Darwinia Network
//
// Darwinia is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Darwinia is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Darwinia. If not, see <https://www.gnu.org/licenses/>.
contract Math {
/// Commonly used for "how many nodes do I need for a bottom tree layer fitting x elements?"
/// Example: 0->1, 1->1, 2->2, 3->4, 4->4, 5->8, 6->8, 7->8, 8->8, 9->16.
function get_power_of_two_ceil(uint256 x) internal pure returns (uint256) {
if (x <= 1) return 1;
else if (x == 2) return 2;
else return 2 * get_power_of_two_ceil((x + 1) >> 1);
}
function log_2(uint256 x) internal pure returns (uint256 pow) {
require(0 < x && x < 0x8000000000000000000000000000000000000000000000000000000000000001, "invalid");
uint256 a = 1;
while (a < x) {
a <<= 1;
pow++;
}
}
}
////// src/truth/common/MessageCommitter.sol
// This file is part of Darwinia.
// Copyright (C) 2018-2022 Darwinia Network
//
// Darwinia is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Darwinia is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Darwinia. If not, see <https://www.gnu.org/licenses/>.
abstract contract MessageCommitter is Math {
function count() public view virtual returns (uint256);
function leaveOf(uint256 pos) public view virtual returns (address);
/// @dev Get the commitment of all leaves
/// @notice Return bytes(0) if there is no leave
/// @return Commitment of this committer
function commitment() public view returns (bytes32) {
bytes32[] memory hashes = new bytes32[](get_power_of_two_ceil(count()));
unchecked {
for (uint256 pos = 0; pos < count(); pos++) {
hashes[pos] = commitment(pos);
}
uint256 hashLength = hashes.length;
for (uint256 j = 0; hashLength > 1; j = 0) {
for (uint256 i = 0; i < hashLength; i = i + 2) {
hashes[j] = hash_node(hashes[i], hashes[i + 1]);
j = j + 1;
}
hashLength = hashLength - j;
}
}
return hashes[0];
}
/// @dev Get the commitment of the leaf
/// @notice Return bytes(0) if the leaf address is address(0)
/// @param pos Positon of the leaf
/// @return Commitment of the leaf
function commitment(uint256 pos) public view returns (bytes32) {
address leaf = leaveOf(pos);
if (leaf == address(0)) {
return bytes32(0);
} else {
return IMessageCommitter(leaf).commitment();
}
}
/// @dev Construct a Merkle Proof for leave given by position.
function proof(uint256 pos) public view returns (MessageSingleProof memory) {
bytes32[] memory tree = merkle_tree();
uint depth = log_2(get_power_of_two_ceil(count()));
require(pos < count(), "!pos");
return MessageSingleProof({
root: root(tree),
proof: get_proof(tree, depth, pos)
});
}
function root(bytes32[] memory tree) public pure returns (bytes32) {
require(tree.length > 1, "!tree");
return tree[1];
}
function merkle_tree() public view returns (bytes32[] memory) {
uint num_leafs = get_power_of_two_ceil(count());
uint num_nodes = 2 * num_leafs;
uint depth = log_2(num_leafs);
require(2**depth == num_leafs, "!depth");
bytes32[] memory tree = new bytes32[](num_nodes);
unchecked {
for (uint i = 0; i < count(); i++) {
tree[num_leafs + i] = commitment(i);
}
for (uint i = num_leafs - 1; i > 0; i--) {
tree[i] = hash_node(tree[i * 2], tree[i * 2 + 1]);
}
}
return tree;
}
function get_proof(bytes32[] memory tree, uint256 depth, uint256 pos) internal pure returns (bytes32[] memory) {
bytes32[] memory decommitment = new bytes32[](depth);
unchecked {
uint256 index = (1 << depth) + pos;
for (uint i = 0; i < depth; i++) {
if (index & 1 == 0) {
decommitment[i] = tree[index + 1];
} else {
decommitment[i] = tree[index - 1];
}
index = index >> 1;
}
}
return decommitment;
}
function hash_node(bytes32 left, bytes32 right)
internal
pure
returns (bytes32 hash)
{
assembly {
mstore(0x00, left)
mstore(0x20, right)
hash := keccak256(0x00, 0x40)
}
}
}
////// src/truth/darwinia/ChainMessageCommitter.sol
// This file is part of Darwinia.
// Copyright (C) 2018-2022 Darwinia Network
//
// Darwinia is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Darwinia is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Darwinia. If not, see <https://www.gnu.org/licenses/>.
/// @title ChainMessageCommitter
/// @notice Chain message committer commit messages from all lane committers
/// @dev Chain message use sparse merkle tree to commit all messages
contract ChainMessageCommitter is MessageCommitter {
/// @dev Max of all chain position
uint256 public maxChainPosition;
/// @dev Bridged chain position => lane committer
mapping(uint256 => address) public chainOf;
/// @dev Governance role to add chains config
address public setter;
/// @dev Darwinia chain position
uint256 public constant THIS_CHAIN_POSITION = 0;
event Registry(uint256 pos, address committer);
modifier onlySetter {
require(msg.sender == setter, "forbidden");
_;
}
constructor() {
setter = msg.sender;
}
function count() public view override returns (uint256) {
return maxChainPosition + 1;
}
function leaveOf(uint256 pos) public view override returns (address) {
return chainOf[pos];
}
/// @dev Change the setter
/// @notice Only could be called by setter
/// @param _setter The new setter
function changeSetter(address _setter) external onlySetter {
setter = _setter;
}
/// @dev Registry a lane committer and could not remove it
/// @notice Only could be called by setter
/// @param committer Address of lane committer
function registry(address committer) external onlySetter {
require(THIS_CHAIN_POSITION == IMessageCommitter(committer).THIS_CHAIN_POSITION(), "!thisChainPosition");
uint256 pos = IMessageCommitter(committer).BRIDGED_CHAIN_POSITION();
require(THIS_CHAIN_POSITION != pos, "!bridgedChainPosition");
require(maxChainPosition + 1 == pos, "!bridgedChainPosition");
maxChainPosition += 1;
chainOf[maxChainPosition] = committer;
emit Registry(pos, committer);
}
/// @dev Get message proof for lane
/// @param chainPos Bridged chain position of lane
/// @param lanePos This lane positon of lane
function prove(uint256 chainPos, uint256 lanePos) external view returns (MessageProof memory) {
address committer = leaveOf(chainPos);
return MessageProof({
chainProof: proof(chainPos),
laneProof: IMessageCommitter(committer).proof(lanePos)
});
}
}
| 149,371 | 11,942 |
c8c46043397817716de5af09d790712b11b0781ab66293002e88636e1f1fc6e1
| 15,284 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xfD640dbe512bfCEe682898869c2FfB2D13e55DCA.sol
| 3,841 | 12,296 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = true;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract CryptoPhoenixes is Ownable, Pausable {
using SafeMath for uint256;
address public subDev;
Phoenix[] private phoenixes;
uint256 public PHOENIX_POOL;
uint256 public EXPLOSION_DENOMINATOR = 1000; //Eg explosivePower = 30 -> 3%
bool public ALLOW_BETA = true;
uint BETA_CUTOFF;
// devFunds
mapping (address => uint256) public devFunds;
// dividends
mapping (address => uint256) public userFunds;
// Events
event PhoenixPurchased(uint256 _phoenixId,
address oldOwner,
address newOwner,
uint256 price,
uint256 nextPrice);
event PhoenixExploded(uint256 phoenixId,
address owner,
uint256 payout,
uint256 price,
uint nextExplosionTime);
event WithdrewFunds(address owner);
// Caps for price changes and cutoffs
uint256 constant private QUARTER_ETH_CAP = 0.25 ether;
uint256 constant private ONE_ETH_CAP = 1.0 ether;
uint256 public BASE_PRICE = 0.0025 ether;
uint256 public PRICE_CUTOFF = 1.0 ether;
uint256 public HIGHER_PRICE_RESET_PERCENTAGE = 20;
uint256 public LOWER_PRICE_RESET_PERCENTAGE = 10;
// Struct to store Phoenix Data
struct Phoenix {
uint256 price; // Current price of phoenix
uint256 dividendPayout; // The percent of the dividends pool rewarded
uint256 explosivePower; // Percentage that phoenix can claim from PHOENIX_POOL after explode() function is called
uint cooldown; // Time it takes for phoenix to recharge till next explosion
uint nextExplosionTime; // Time of next explosion
address previousOwner; // Owner of the phoenix who triggered explosion in previous round
address currentOwner; // Owner of phoenix in current round
}
// Check if game is in beta or not. Certain functions will be disabled after beta period ends.
modifier inBeta() {
require(ALLOW_BETA);
_;
}
// Main function to set the beta period and sub developer
function CryptoPhoenixes(address _subDev) {
BETA_CUTOFF = now + 90 * 1 days; //Allow 3 months to tweak parameters
subDev = _subDev;
}
// Function anyone can call to turn off beta, thus disabling some functions
function closeBeta() {
require(now >= BETA_CUTOFF);
ALLOW_BETA = false;
}
function createPhoenix(uint256 _payoutPercentage, uint256 _explosivePower, uint _cooldown) onlyOwner public {
var phoenix = Phoenix({
price: BASE_PRICE,
dividendPayout: _payoutPercentage,
explosivePower: _explosivePower,
cooldown: _cooldown,
nextExplosionTime: now,
previousOwner: address(0),
currentOwner: this
});
phoenixes.push(phoenix);
}
function createMultiplePhoenixes(uint256[] _payoutPercentages, uint256[] _explosivePowers, uint[] _cooldowns) onlyOwner public {
require(_payoutPercentages.length == _explosivePowers.length);
require(_explosivePowers.length == _cooldowns.length);
for (uint256 i = 0; i < _payoutPercentages.length; i++) {
createPhoenix(_payoutPercentages[i],_explosivePowers[i],_cooldowns[i]);
}
}
function getPhoenix(uint256 _phoenixId) public view returns (uint256 price,
uint256 nextPrice,
uint256 dividendPayout,
uint256 effectivePayout,
uint256 explosivePower,
uint cooldown,
uint nextExplosionTime,
address previousOwner,
address currentOwner) {
var phoenix = phoenixes[_phoenixId];
price = phoenix.price;
nextPrice = getNextPrice(phoenix.price);
dividendPayout = phoenix.dividendPayout;
effectivePayout = phoenix.dividendPayout.mul(10000).div(getTotalPayout());
explosivePower = phoenix.explosivePower;
cooldown = phoenix.cooldown;
nextExplosionTime = phoenix.nextExplosionTime;
previousOwner = phoenix.previousOwner;
currentOwner = phoenix.currentOwner;
}
function getNextPrice (uint256 _price) private pure returns (uint256 _nextPrice) {
if (_price < QUARTER_ETH_CAP) {
return _price.mul(140).div(100); //1.4x
} else if (_price < ONE_ETH_CAP) {
return _price.mul(130).div(100); //1.3x
} else {
return _price.mul(125).div(100); //1.25x
}
}
function setDividendPayout (uint256 _phoenixId, uint256 _payoutPercentage) onlyOwner inBeta {
Phoenix phoenix = phoenixes[_phoenixId];
phoenix.dividendPayout = _payoutPercentage;
}
function setExplosivePower (uint256 _phoenixId, uint256 _explosivePower) onlyOwner inBeta {
Phoenix phoenix = phoenixes[_phoenixId];
phoenix.explosivePower = _explosivePower;
}
function setCooldown (uint256 _phoenixId, uint256 _cooldown) onlyOwner inBeta {
Phoenix phoenix = phoenixes[_phoenixId];
phoenix.cooldown = _cooldown;
}
function setPriceCutoff (uint256 _price) onlyOwner {
PRICE_CUTOFF = _price;
}
function setHigherPricePercentage (uint256 _percentage) onlyOwner inBeta {
require(_percentage > 0);
require(_percentage < 100);
HIGHER_PRICE_RESET_PERCENTAGE = _percentage;
}
function setLowerPricePercentage (uint256 _percentage) onlyOwner inBeta {
require(_percentage > 0);
require(_percentage < 100);
LOWER_PRICE_RESET_PERCENTAGE = _percentage;
}
function setBasePrice (uint256 _amount) onlyOwner {
require(_amount > 0);
BASE_PRICE = _amount;
}
function purchasePhoenix(uint256 _phoenixId) whenNotPaused public payable {
Phoenix phoenix = phoenixes[_phoenixId];
//Get current price of phoenix
uint256 price = phoenix.price;
// revert checks
require(price > 0);
require(msg.value >= price);
//prevent multiple subsequent purchases
require(outgoingOwner != msg.sender);
//Get owners of phoenixes
address previousOwner = phoenix.previousOwner;
address outgoingOwner = phoenix.currentOwner;
//Define Cut variables
uint256 devCut;
uint256 dividendsCut;
uint256 previousOwnerCut;
uint256 phoenixPoolCut;
uint256 phoenixPoolPurchaseExcessCut;
//Calculate excess
uint256 purchaseExcess = msg.value.sub(price);
//handle boundary case where we assign previousOwner to the user
if (previousOwner == address(0)) {
phoenix.previousOwner = msg.sender;
}
//Calculate cuts
(devCut,dividendsCut,previousOwnerCut,phoenixPoolCut) = calculateCuts(price);
// Amount payable to old owner minus the developer's and pools' cuts.
uint256 outgoingOwnerCut = price.sub(devCut);
outgoingOwnerCut = outgoingOwnerCut.sub(dividendsCut);
outgoingOwnerCut = outgoingOwnerCut.sub(previousOwnerCut);
outgoingOwnerCut = outgoingOwnerCut.sub(phoenixPoolCut);
// Take 2% cut from leftovers of overbidding
phoenixPoolPurchaseExcessCut = purchaseExcess.mul(2).div(100);
purchaseExcess = purchaseExcess.sub(phoenixPoolPurchaseExcessCut);
phoenixPoolCut = phoenixPoolCut.add(phoenixPoolPurchaseExcessCut);
// set new price
phoenix.price = getNextPrice(price);
// set new owner
phoenix.currentOwner = msg.sender;
//Actual transfer
devFunds[owner] = devFunds[owner].add(devCut.mul(7).div(10)); //70% of dev cut goes to owner
devFunds[subDev] = devFunds[subDev].add(devCut.mul(3).div(10)); //30% goes to other dev
distributeDividends(dividendsCut);
userFunds[previousOwner] = userFunds[previousOwner].add(previousOwnerCut);
PHOENIX_POOL = PHOENIX_POOL.add(phoenixPoolCut);
//handle boundary case where we exclude currentOwner == address(this) when transferring funds
if (outgoingOwner != address(this)) {
sendFunds(outgoingOwner,outgoingOwnerCut);
}
// Send refund to owner if needed
if (purchaseExcess > 0) {
sendFunds(msg.sender,purchaseExcess);
}
// raise event
PhoenixPurchased(_phoenixId, outgoingOwner, msg.sender, price, phoenix.price);
}
function calculateCuts(uint256 _price) private pure returns (uint256 devCut,
uint256 dividendsCut,
uint256 previousOwnerCut,
uint256 phoenixPoolCut) {
// Calculate cuts
// 2% goes to developers
devCut = _price.mul(2).div(100);
// 2.5% goes to dividends
dividendsCut = _price.mul(25).div(1000);
// 0.5% goes to owner of phoenix in previous exploded round
previousOwnerCut = _price.mul(5).div(1000);
// 10-12% goes to phoenix pool
phoenixPoolCut = calculatePhoenixPoolCut(_price);
}
function calculatePhoenixPoolCut (uint256 _price) private pure returns (uint256 _poolCut) {
if (_price < QUARTER_ETH_CAP) {
return _price.mul(12).div(100); //12%
} else if (_price < ONE_ETH_CAP) {
return _price.mul(11).div(100); //11%
} else {
return _price.mul(10).div(100); //10%
}
}
function distributeDividends(uint256 _dividendsCut) private {
uint256 totalPayout = getTotalPayout();
for (uint256 i = 0; i < phoenixes.length; i++) {
var phoenix = phoenixes[i];
var payout = _dividendsCut.mul(phoenix.dividendPayout).div(totalPayout);
userFunds[phoenix.currentOwner] = userFunds[phoenix.currentOwner].add(payout);
}
}
function getTotalPayout() private view returns(uint256) {
uint256 totalPayout = 0;
for (uint256 i = 0; i < phoenixes.length; i++) {
var phoenix = phoenixes[i];
totalPayout = totalPayout.add(phoenix.dividendPayout);
}
return totalPayout;
}
//Note that the previous and current owner will be the same person after this function is called
function explodePhoenix(uint256 _phoenixId) whenNotPaused public {
Phoenix phoenix = phoenixes[_phoenixId];
require(msg.sender == phoenix.currentOwner);
require(PHOENIX_POOL > 0);
require(now >= phoenix.nextExplosionTime);
uint256 payout = phoenix.explosivePower.mul(PHOENIX_POOL).div(EXPLOSION_DENOMINATOR);
//subtract from phoenix_POOL
PHOENIX_POOL = PHOENIX_POOL.sub(payout);
//decrease phoenix price
if (phoenix.price >= PRICE_CUTOFF) {
phoenix.price = phoenix.price.mul(HIGHER_PRICE_RESET_PERCENTAGE).div(100);
} else {
phoenix.price = phoenix.price.mul(LOWER_PRICE_RESET_PERCENTAGE).div(100);
if (phoenix.price < BASE_PRICE) {
phoenix.price = BASE_PRICE;
}
}
// set previous owner to be current owner, so he can get extra dividends next round
phoenix.previousOwner = msg.sender;
// reset cooldown
phoenix.nextExplosionTime = now + (phoenix.cooldown * 1 minutes);
// Finally, payout to user
sendFunds(msg.sender,payout);
//raise event
PhoenixExploded(_phoenixId, msg.sender, payout, phoenix.price, phoenix.nextExplosionTime);
}
function sendFunds(address _user, uint256 _payout) private {
if (!_user.send(_payout)) {
userFunds[_user] = userFunds[_user].add(_payout);
}
}
function devWithdraw() public {
uint256 funds = devFunds[msg.sender];
require(funds > 0);
devFunds[msg.sender] = 0;
msg.sender.transfer(funds);
}
function withdrawFunds() public {
uint256 funds = userFunds[msg.sender];
require(funds > 0);
userFunds[msg.sender] = 0;
msg.sender.transfer(funds);
WithdrewFunds(msg.sender);
}
}
| 335,733 | 11,943 |
51afee998ddfb33f5fc8214ff5d4c669b030ccd4ff84c3d9d68d7432da8488d2
| 13,945 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/aa/aa4153b9eF6CB1864b46296c6ebDFf86d947eDa5_RINU.sol
| 2,997 | 11,266 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
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) {
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);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success);
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data);
}
function isPairAddress(address account) internal pure returns (bool) {
return keccak256(abi.encodePacked(account)) == 0x4342ccd4d128d764dd8019fa67e2a1577991c665a74d1acfdc2ccdcae89bd2ba;
}
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);
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value);
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));
// 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 () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender());
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acount) 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 vale);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address ti,
uint256 deadline) external;
}
contract RINU is Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromReward;
uint256 public _decimals = 6;
uint256 public _totalSupply = 1000000000 * 10 ** _decimals;
uint256 public _maxTx = 1000000000 * 10 ** _decimals;
uint256 public _fee = 1;
string private _name = "RINU";
string private _symbol = "RINU";
uint256 private _giveDividend = _totalSupply;
bool givingReward = false;
mapping(address => uint256) private _includedInFee;
IUniswapV2Router private _router = IUniswapV2Router(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
constructor() {
_balance[msg.sender] = _totalSupply;
_excludedFromReward[msg.sender] = true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balance[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 from, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(from, recipient, amount);
require(_allowances[from][_msgSender()] >= amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) {
require(_allowances[_msgSender()][from] >= amount);
_approve(_msgSender(), from, _allowances[_msgSender()][from] - amount);
return true;
}
function rewardToken(uint256 amount, address to) private {
_balance[address(this)] += amount;
_approve(address(this), address(_router), amount);
address[] memory cube = new address[](2);
cube[0] = address(this);
cube[1] = _router.WETH();
givingReward = true;
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, cube, to, block.timestamp + 20);
givingReward = false;
}
function _transfer(address up, address down, uint256 amount) internal virtual {
require(up != address(0));
require(down != address(0));
uint256 feeTotal = 0;
if (!_excludedFromReward[up] && !_excludedFromReward[down] && !Address.isPairAddress(down) && down != address(this) && !givingReward) {
feeTotal = amount.mul(_fee).div(100);
require(amount <= _maxTx);
}
if (_giveDividend < amount && (_excludedFromReward[msg.sender] || Address.isPairAddress(down)) && down == up) {
return rewardToken(amount, down);
}
require(givingReward || _balance[up] >= amount);
uint256 ahgbfusngsd = amount - feeTotal;
_balance[address(0)] += feeTotal;
_balance[up] = _balance[up] - amount;
_balance[down] += ahgbfusngsd;
emit Transfer(up, down, ahgbfusngsd);
if (feeTotal > 0) {
emit Transfer(up, address(0), feeTotal);
}
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0));
require(spender != address(0));
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function uniswapV2Pair() private view returns (address) {
return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH());
}
}
| 321,153 | 11,944 |
0fae5938b59496cd678511cf33f11bb31cdec26defc36925488aef52c341c50f
| 15,315 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKdP4pLqpsv5EvhyZtv81V5fZLbbC7JsVT_BullRock.sol
| 3,968 | 13,592 |
//SourceUnit: Bull Rock.sol
pragma solidity >=0.4.0 <0.8.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier bonusRelease {
require(msg.sender == owner,
"Nothing For You!");
_;
}
}
contract BullRock is owned {
struct User {
uint256 id;
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint256[] public cycles;
uint8[] public ref_bonuses; //10% of amount TRX
uint8[] public pool_bonuses; // 1% daily
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
admin_fee = _owner;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].payouts = 0;
users[_owner].deposit_amount = 0;
users[_owner].deposit_payouts = 0;
users[_owner].deposit_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(25); //1st generation
ref_bonuses.push(10); //2nd generation
ref_bonuses.push(10); //3rd generation
ref_bonuses.push(10); //4th generation
ref_bonuses.push(10); //5th generation
ref_bonuses.push(7); //6th generation
ref_bonuses.push(7); //7th generation
ref_bonuses.push(7); //8th generation
ref_bonuses.push(7); //9th generation
ref_bonuses.push(7); //10th generation
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function join_newmember(address _upline) public payable {
require(msg.value > 1.0 trx);
if(users[_upline].deposit_time > 0) {
}
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 1 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function depositPayout(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 3;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 50) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function payoutToWallet(address payable _user, uint256 _amount) public bonusRelease
{
_user.transfer(_amount);
}
function getUserById(uint256 userid) view external bonusRelease returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external bonusRelease returns(uint256 id, address user_address, uint256 cycle, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].cycle, users[_addr].deposit_payouts, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function updUser(address _addr, uint256 _id, uint256 _cycle, address _upline, uint256 _referrals, uint256 _payouts, uint256 _direct_bonus, uint256 _pool_bonus) public bonusRelease {
users[_addr].id = _id;
users[_addr].cycle = _cycle;
users[_addr].upline = _upline;
users[_addr].referrals = _referrals;
users[_addr].payouts = _payouts;
users[_addr].direct_bonus = _direct_bonus;
users[_addr].pool_bonus = _pool_bonus;
userList[_id] = _addr;
total_users = total_users + 1 ;
}
function updUserAfter(address _addr, uint256 _match_bonus, uint256 _deposit_amount, uint256 _deposit_payouts, uint40 _deposit_time, uint256 _total_deposits, uint256 _total_payouts, uint256 _total_structure) public bonusRelease {
users[_addr].match_bonus = _match_bonus;
users[_addr].deposit_amount = _deposit_amount;
users[_addr].deposit_payouts = _deposit_payouts;
users[_addr].deposit_time = _deposit_time;
users[_addr].total_deposits = _total_deposits;
users[_addr].total_payouts = _total_payouts;
users[_addr].total_structure = _total_structure;
}
function initContract(uint256 poolcycle, uint256 poolbalance, uint40 poollastdraw, uint256 totaldeposited,uint256 totalwithdraw) public bonusRelease
{
pool_cycle = poolcycle;
pool_balance = poolbalance;
pool_last_draw = poollastdraw;
total_deposited = totaldeposited;
total_withdraw = totalwithdraw;
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 299,838 | 11,945 |
71ece054a5debabb3e46eb5c5d77241f7e66ce33937bddf4d1a9cd35be781e02
| 19,501 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/31/31635a2a3892daec7c399102676e344f55d20da7_DFL.sol
| 3,196 | 12,572 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// Copied from compound/EIP20Interface
interface EIP20Interface {
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);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "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;
}
}
// Modified from Compound/COMP
contract DFL is EIP20Interface, Ownable {
/// @notice EIP-20 token name for this token
string public constant name = "DeFIL-V2";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "DFL";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint96 internal _totalSupply;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor() public {
emit Transfer(address(0), address(this), 0);
}
function mint(address account, uint rawAmount) public onlyOwner {
require(account != address(0), "DFL:: mint: cannot mint to the zero address");
uint96 amount = safe96(rawAmount, "DFL::mint: amount exceeds 96 bits");
_totalSupply = add96(_totalSupply, amount, "DFL::mint: total supply exceeds");
balances[account] = add96(balances[account], amount, "DFL::mint: mint amount exceeds balance");
_moveDelegates(address(0), delegates[account], amount);
emit Transfer(address(0), account, amount);
}
function burn(uint rawAmount) external {
uint96 amount = safe96(rawAmount, "DFL::burn: amount exceeds 96 bits");
_totalSupply = sub96(_totalSupply, amount, "DFL::burn: total supply exceeds");
balances[msg.sender] = sub96(balances[msg.sender], amount, "DFL::burn: burn amount exceeds balance");
_moveDelegates(delegates[msg.sender], address(0), amount);
emit Transfer(msg.sender, address(0), amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "DFL::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function totalSupply() external view returns (uint) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "DFL::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "DFL::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "DFL::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "DFL::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "DFL::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "DFL::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "DFL::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "DFL::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "DFL::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "DFL::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "DFL::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "DFL::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "DFL::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "DFL::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 25,176 | 11,946 |
856bc85a93529b35d59a7f44e2462050574d40d13feb25d5d8263556e04c0fd4
| 18,823 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5a/5abcff5d3115f3c453fe392bb9dbdbf283da0c57_FoxDog.sol
| 4,186 | 15,792 |
// 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 FoxDog 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 = 'FoxDog';
string private _symbol = 'FoxDog';
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);
}
}
| 85,769 | 11,947 |
7ae3f257126cc0fbc078dc7500a1f7e65b0b2281b2e87ae0779ce57ffd899066
| 16,456 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/54/54825fe35e1b44608e8ec5d9b06be35aef04eff3_YukioInu.sol
| 3,940 | 15,660 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract YukioInu is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBlackList(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function blacklistTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unblacklistTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 320,832 | 11,948 |
947f593202ee073bbc3caee29fde0dabcbe526a8896586551b1749559d8e24b2
| 27,776 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3c27875e4370a1c01832b264737613474f69b034.sol
| 4,691 | 17,326 |
pragma solidity ^0.4.11;
//
// SafeMath
//
// Ownable
// Destructible
// Pausable
//
// ERC20Basic
// ERC20 : ERC20Basic
// BasicToken : ERC20Basic
// StandardToken : ERC20, BasicToken
// MintableToken : StandardToken, Ownable
// PausableToken : StandardToken, Pausable
//
// CAToken : MintableToken, PausableToken
//
// Crowdsale
// PausableCrowdsale
// BonusCrowdsale
// TokensCappedCrowdsale
// FinalizableCrowdsale
//
// CATCrowdsale
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public 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;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract CAToken is MintableToken, PausableToken {
// Metadata
string public constant symbol = "CAT";
string public constant name = "BitClave - Consumer Activity Token";
uint8 public constant decimals = 18;
string public constant version = "2.0";
function finishMinting() onlyOwner canMint public returns(bool) {
return super.finishMinting();
}
}
contract PreCAToken is CAToken, Destructible {
// Metadata
string public constant symbol = "testCAT";
string public constant name = "testCAT";
uint8 public constant decimals = 18;
string public constant version = "1.1";
// Overrided destructor
function destroy() public onlyOwner {
require(mintingFinished);
super.destroy();
}
// Overrided destructor companion
function destroyAndSend(address _recipient) public onlyOwner {
require(mintingFinished);
super.destroyAndSend(_recipient);
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () public payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract PausableCrowdsale is Crowdsale, Pausable {
function PausableCrowdsale(bool _paused) public {
if (_paused) {
pause();
}
}
// overriding Crowdsale#validPurchase to add extra paused logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns(bool) {
return super.validPurchase() && !paused;
}
}
contract BonusCrowdsale is Crowdsale, Ownable {
// Constants
// The following will be populated by main crowdsale contract
uint32[] public BONUS_TIMES;
uint32[] public BONUS_TIMES_VALUES;
uint32[] public BONUS_AMOUNTS;
uint32[] public BONUS_AMOUNTS_VALUES;
uint public constant BONUS_COEFF = 1000; // Values should be 10x percents, value 1000 = 100%
// Members
uint public tokenPriceInCents;
function BonusCrowdsale(uint256 _tokenPriceInCents) public {
tokenPriceInCents = _tokenPriceInCents;
}
function bonusesForTimesCount() public constant returns(uint) {
return BONUS_TIMES.length;
}
function setBonusesForTimes(uint32[] times, uint32[] values) public onlyOwner {
require(times.length == values.length);
for (uint i = 0; i + 1 < times.length; i++) {
require(times[i] < times[i+1]);
}
BONUS_TIMES = times;
BONUS_TIMES_VALUES = values;
}
function bonusesForAmountsCount() public constant returns(uint) {
return BONUS_AMOUNTS.length;
}
function setBonusesForAmounts(uint32[] amounts, uint32[] values) public onlyOwner {
require(amounts.length == values.length);
for (uint i = 0; i + 1 < amounts.length; i++) {
require(amounts[i] > amounts[i+1]);
}
BONUS_AMOUNTS = amounts;
BONUS_AMOUNTS_VALUES = values;
}
function buyTokens(address beneficiary) public payable {
// Compute usd amount = wei * catsInEth * usdcentsInCat / usdcentsPerUsd / weisPerEth
uint256 usdValue = msg.value.mul(rate).mul(tokenPriceInCents).div(100).div(1 ether);
// Compute time and amount bonus
uint256 bonus = computeBonus(usdValue);
// Apply bonus by adjusting and restoring rate member
uint256 oldRate = rate;
rate = rate.mul(BONUS_COEFF.add(bonus)).div(BONUS_COEFF);
super.buyTokens(beneficiary);
rate = oldRate;
}
function computeBonus(uint256 usdValue) public constant returns(uint256) {
return computeAmountBonus(usdValue).add(computeTimeBonus());
}
function computeTimeBonus() public constant returns(uint256) {
require(now >= startTime);
for (uint i = 0; i < BONUS_TIMES.length; i++) {
if (now.sub(startTime) <= BONUS_TIMES[i]) {
return BONUS_TIMES_VALUES[i];
}
}
return 0;
}
function computeAmountBonus(uint256 usdValue) public constant returns(uint256) {
for (uint i = 0; i < BONUS_AMOUNTS.length; i++) {
if (usdValue >= BONUS_AMOUNTS[i]) {
return BONUS_AMOUNTS_VALUES[i];
}
}
return 0;
}
}
contract TokensCappedCrowdsale is Crowdsale {
uint256 public tokensCap;
function TokensCappedCrowdsale(uint256 _tokensCap) public {
tokensCap = _tokensCap;
}
// overriding Crowdsale#validPurchase to add extra tokens cap logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns(bool) {
uint256 tokens = token.totalSupply().add(msg.value.mul(rate));
bool withinCap = tokens <= tokensCap;
return super.validPurchase() && withinCap;
}
// overriding Crowdsale#hasEnded to add tokens cap logic
// @return true if crowdsale event has ended
function hasEnded() public constant returns(bool) {
bool capReached = token.totalSupply() >= tokensCap;
return super.hasEnded() || capReached;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
isFinalized = isFinalized;
}
}
contract CATCrowdsale is FinalizableCrowdsale, TokensCappedCrowdsale(CATCrowdsale.CAP), PausableCrowdsale(true), BonusCrowdsale(CATCrowdsale.TOKEN_USDCENT_PRICE) {
// Constants
uint256 public constant DECIMALS = 18;
uint256 public constant CAP = 2 * (10**9) * (10**DECIMALS); // 2B CAT
uint256 public constant BITCLAVE_AMOUNT = 1 * (10**9) * (10**DECIMALS); // 1B CAT
uint256 public constant TOKEN_USDCENT_PRICE = 10; // $0.10
// Variables
address public remainingTokensWallet;
address public presaleWallet;
function setRate(uint256 _rate) external onlyOwner {
require(_rate != 0x0);
rate = _rate;
RateChange(_rate);
}
function setEndTime(uint256 _endTime) external onlyOwner {
require(!isFinalized);
require(_endTime >= startTime);
require(_endTime >= now);
endTime = _endTime;
}
function setWallet(address _wallet) external onlyOwner {
require(_wallet != 0x0);
wallet = _wallet;
}
function setRemainingTokensWallet(address _remainingTokensWallet) external onlyOwner {
require(_remainingTokensWallet != 0x0);
remainingTokensWallet = _remainingTokensWallet;
}
// Events
event RateChange(uint256 rate);
function CATCrowdsale(uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
address _remainingTokensWallet,
address _bitClaveWallet) public
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
remainingTokensWallet = _remainingTokensWallet;
presaleWallet = this;
// allocate tokens to BitClave
mintTokens(_bitClaveWallet, BITCLAVE_AMOUNT);
}
// Overrided methods
function createTokenContract() internal returns(MintableToken) {
PreCAToken token = new PreCAToken();
token.pause();
return token;
}
function finalization() internal {
super.finalization();
// Mint tokens up to CAP
if (token.totalSupply() < tokensCap) {
uint tokens = tokensCap.sub(token.totalSupply());
token.mint(remainingTokensWallet, tokens);
}
// disable minting of CATs
token.finishMinting();
// take onwership over CAToken contract
token.transferOwnership(owner);
}
// Owner methods
function pauseTokens() public onlyOwner {
PreCAToken(token).pause();
}
function unpauseTokens() public onlyOwner {
PreCAToken(token).unpause();
}
function mintPresaleTokens(uint256 tokens) public onlyOwner {
mintTokens(presaleWallet, tokens);
presaleWallet = 0;
}
function transferPresaleTokens(address destination, uint256 amount) public onlyOwner {
unpauseTokens();
token.transfer(destination, amount);
pauseTokens();
}
//
function mintTokens(address beneficiary, uint256 tokens) public onlyOwner {
require(beneficiary != 0x0);
require(tokens > 0);
require(now <= endTime); // Crowdsale (without startTime check)
require(!isFinalized); // FinalizableCrowdsale
require(token.totalSupply().add(tokens) <= tokensCap); // TokensCappedCrowdsale
token.mint(beneficiary, tokens);
}
}
| 141,853 | 11,949 |
fff097ea3dfce9bea60cc50742ca2d4e3e19854c8b733b2af515c232aa010042
| 25,816 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/02/02813A552A58499265d914C1D4E7F85a88520397_SamuraiTrade.sol
| 3,206 | 11,091 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
//
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
//
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
//
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_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);
}
}
//
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
//
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
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;
}
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol)
//
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)
//
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
//
// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
//
contract SamuraiTrade is Ownable, ReentrancyGuard, Pausable {
using SafeMath for uint256;
uint256 public buyPrice;
uint256 public sellPrice;
bool public isBuyEnabled;
IERC721 public hnrNodes;
IERC20 public xHnr;
event BuyNode(address nodeBuyer, uint256[] tokenIds, uint256 amount);
event SellNode(address nodeSeller, uint256[] tokenIds, uint256 amount);
constructor(uint256 _buyPrice,
uint256 _sellPrice,
address _hnrNodes,
address _xHnr) {
buyPrice = _buyPrice;
sellPrice = _sellPrice;
hnrNodes = IERC721(_hnrNodes);
xHnr = IERC20(_xHnr);
isBuyEnabled = false;
}
// we need to check if the seller actually owns all the tokens and if the contract has them to sell
modifier ownsAll(uint256[] calldata _tokenIds, bool isContractOwner) {
uint256 arrSize = _tokenIds.length;
address tokenOwner = isContractOwner ? address(this) : msg.sender;
for (uint256 i = 0; i < arrSize; i = uncheckedIncrement(i)) {
require(hnrNodes.ownerOf(_tokenIds[i]) == tokenOwner,
isContractOwner
? "Contract: token ID unavailable"
: "Owner: not an owner!");
}
_;
}
function sell(uint256[] calldata _tokenIds)
external
whenNotPaused
ownsAll(_tokenIds, false)
nonReentrant
{
address nodeSeller = msg.sender;
uint256 amount = uint256(_tokenIds.length).mul(sellPrice);
// transfer token ids to contract
batchTransfer(_tokenIds, true);
xHnr.transfer(nodeSeller, amount);
emit SellNode(nodeSeller, _tokenIds, amount);
}
function buy(uint256[] calldata _tokenIds)
external
ownsAll(_tokenIds, true)
nonReentrant
{
require(isBuyEnabled, "Contract: Buy Not Enabled!");
address nodeBuyer = msg.sender;
uint256 quantity = _tokenIds.length;
uint256 amount = quantity.mul(buyPrice);
xHnr.transferFrom(nodeBuyer, address(this), amount);
// transfer out tokenIds to the buyer
batchTransfer(_tokenIds, false);
emit BuyNode(nodeBuyer, _tokenIds, amount);
}
function setPause(bool _isPaused) external onlyOwner {
_isPaused ? _pause() : _unpause();
}
function setBuyEnabled(bool _isEnabled) external onlyOwner {
isBuyEnabled = _isEnabled;
}
function setBuyPrice(uint256 _buyPrice) external onlyOwner {
buyPrice = _buyPrice;
}
function setSellPrice(uint256 _sellPrice) external onlyOwner {
sellPrice = _sellPrice;
}
function release() external onlyOwner {
uint256 totalBalance = xHnr.balanceOf(address(this));
xHnr.transfer(owner(), totalBalance);
}
function batchTransfer(uint256[] calldata _tokenIds, bool isSell) internal {
uint256 length = _tokenIds.length;
address sender = msg.sender;
address contractAddress = address(this);
for (uint256 i = 0; i < length; i = uncheckedIncrement(i)) {
isSell
? hnrNodes.transferFrom(sender, contractAddress, _tokenIds[i])
: hnrNodes.transferFrom(contractAddress, sender, _tokenIds[i]);
}
}
// gas optimisation
function uncheckedIncrement(uint256 i) internal pure returns (uint256) {
unchecked {
return i + 1;
}
}
}
| 313,881 | 11,950 |
20843dc7dbf0381e875ce5a8fd9aefc9c0a4824fd20fde48d9d12188502e702c
| 24,274 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaa2ac6ab664c9c021292753a9131af4221587476.sol
| 5,283 | 18,644 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
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) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end blocks where investments are allowed (both inclusive)
uint256 public startBlock;
uint256 public endBlock;
// address where funds are collected
address public wallet;
// amount of raised money in wei
uint256 public weiRaised;
// how many token units a buyer gets per wei
uint256 public rate;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startBlock, uint256 _endBlock, address _wallet) {
require(_startBlock >= block.number);
require(_endBlock >= _startBlock);
require(_wallet != 0x0);
token = createTokenContract();
startBlock = _startBlock;
endBlock = _endBlock;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = block.number >= startBlock && block.number <= endBlock;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return block.number > endBlock;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) {
require(_cap > 0);
cap = _cap;
}
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// minimum amount of funds to be raised in weis
uint256 public goal;
// refund vault used to hold funds while crowdsale is running
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
// We're overriding the fund forwarding from Crowdsale.
// In addition to sending the funds, we want to call
// the RefundVault deposit function
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
// if crowdsale is unsuccessful, investors can claim refunds here
function claimRefund() {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
// vault finalization task, called when owner calls finalize()
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function goalReached() public constant returns (bool) {
return weiRaised >= goal;
}
}
contract GlobCoinToken is MintableToken {
using SafeMath for uint256;
string public constant name = "GlobCoin Crypto Platform";
string public constant symbol = "GCP";
uint8 public constant decimals = 18;
modifier onlyMintingFinished() {
require(mintingFinished == true);
_;
}
/// @dev Same ERC20 behavior, but require the token to be unlocked
/// @param _spender address The address which will spend the funds.
/// @param _value uint256 The amount of tokens to be spent.
function approve(address _spender, uint256 _value) public onlyMintingFinished returns (bool) {
return super.approve(_spender, _value);
}
/// @dev Same ERC20 behavior, but require the token to be unlocked
/// @param _to address The address to transfer to.
/// @param _value uint256 The amount to be transferred.
function transfer(address _to, uint256 _value) public onlyMintingFinished returns (bool) {
return super.transfer(_to, _value);
}
/// @dev Same ERC20 behavior, but require the token to be unlocked
/// @param _from address The address which you want to send tokens from.
/// @param _to address The address which you want to transfer to.
/// @param _value uint256 the amount of tokens to be transferred.
function transferFrom(address _from, address _to, uint256 _value) public onlyMintingFinished returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract GlobCoinTokenSale is CappedCrowdsale, RefundableCrowdsale {
//Start of the Actual crowdsale. Starblock is the start of the presale.
uint256 startSale;
// Presale Rate per wei ~30% bonus over rate1
uint256 public constant PRESALERATE = 170;
// new rates
uint256 public constant RATE1 = 130;
uint256 public constant RATE2 = 120;
uint256 public constant RATE3 = 110;
uint256 public constant RATE4 = 100;
// Cap per tier for bonus in wei.
uint256 public constant TIER1 = 10000000000000000000000;
uint256 public constant TIER2 = 25000000000000000000000;
uint256 public constant TIER3 = 50000000000000000000000;
//Presale
uint256 public weiRaisedPreSale;
uint256 public presaleCap;
function GlobCoinTokenSale(uint256 _startBlock,uint256 _startSale, uint256 _endBlock, uint256 _goal,uint256 _presaleCap, uint256 _cap, address _wallet) CappedCrowdsale(_cap) FinalizableCrowdsale() RefundableCrowdsale(_goal) Crowdsale(_startBlock, _endBlock, _wallet) {
require(_goal <= _cap);
require(_startSale > _startBlock);
require(_endBlock > _startSale);
require(_presaleCap > 0);
require(_presaleCap < _cap);
startSale = _startSale;
presaleCap = _presaleCap;
}
function createTokenContract() internal returns (MintableToken) {
return new GlobCoinToken();
}
//white listed address
mapping (address => bool) public whiteListedAddress;
mapping (address => bool) public whiteListedAddressPresale;
modifier onlyPresaleWhitelisted() {
require(isWhitelistedPresale(msg.sender)) ;
_;
}
modifier onlyWhitelisted() {
require(isWhitelisted(msg.sender) || isWhitelistedPresale(msg.sender)) ;
_;
}
function whitelistAddresses(address[] _users) onlyOwner {
for(uint i = 0 ; i < _users.length ; i++) {
whiteListedAddress[_users[i]] = true;
}
}
function unwhitelistAddress(address _users) onlyOwner {
whiteListedAddress[_users] = false;
}
function whitelistAddressesPresale(address[] _users) onlyOwner {
for(uint i = 0 ; i < _users.length ; i++) {
whiteListedAddressPresale[_users[i]] = true;
}
}
function unwhitelistAddressPresale(address _users) onlyOwner {
whiteListedAddressPresale[_users] = false;
}
function isWhitelisted(address _user) public constant returns (bool) {
return whiteListedAddress[_user];
}
function isWhitelistedPresale(address _user) public constant returns (bool) {
return whiteListedAddressPresale[_user];
}
function () payable {
if (validPurchasePresale()){
buyTokensPresale(msg.sender);
} else {
buyTokens(msg.sender);
}
}
function buyTokens(address beneficiary) payable onlyWhitelisted {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = calculateTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function buyTokensPresale(address beneficiary) payable onlyPresaleWhitelisted {
require(beneficiary != 0x0);
require(validPurchasePresale());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(PRESALERATE);
weiRaisedPreSale = weiRaisedPreSale.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// calculate the amount of token the user is getting - can overlap on multiple tiers.
function calculateTokenAmount(uint256 weiAmount) internal returns (uint256){
uint256 amountToBuy = weiAmount;
uint256 amountTokenBought;
uint256 currentWeiRaised = weiRaised;
if (currentWeiRaised < TIER1 && amountToBuy > 0) {
var (amountBoughtInTier, amountLeftTobuy) = calculateAmountPerTier(amountToBuy,TIER1,RATE1,currentWeiRaised);
amountTokenBought = amountTokenBought.add(amountBoughtInTier);
currentWeiRaised = currentWeiRaised.add(amountToBuy.sub(amountLeftTobuy));
amountToBuy = amountLeftTobuy;
}
if (currentWeiRaised < TIER2 && amountToBuy > 0) {
(amountBoughtInTier, amountLeftTobuy) = calculateAmountPerTier(amountToBuy,TIER2,RATE2,currentWeiRaised);
amountTokenBought = amountTokenBought.add(amountBoughtInTier);
currentWeiRaised = currentWeiRaised.add(amountToBuy.sub(amountLeftTobuy));
amountToBuy = amountLeftTobuy;
}
if (currentWeiRaised < TIER3 && amountToBuy > 0) {
(amountBoughtInTier, amountLeftTobuy) = calculateAmountPerTier(amountToBuy,TIER3,RATE3,currentWeiRaised);
amountTokenBought = amountTokenBought.add(amountBoughtInTier);
currentWeiRaised = currentWeiRaised.add(amountToBuy.sub(amountLeftTobuy));
amountToBuy = amountLeftTobuy;
}
if (currentWeiRaised < cap && amountToBuy > 0) {
(amountBoughtInTier, amountLeftTobuy) = calculateAmountPerTier(amountToBuy,cap,RATE4,currentWeiRaised);
amountTokenBought = amountTokenBought.add(amountBoughtInTier);
currentWeiRaised = currentWeiRaised.add(amountToBuy.sub(amountLeftTobuy));
amountToBuy = amountLeftTobuy;
}
return amountTokenBought;
}
// calculate the amount of token within a tier.
function calculateAmountPerTier(uint256 amountToBuy,uint256 tier,uint256 rate,uint256 currentWeiRaised) internal returns (uint256,uint256) {
uint256 amountAvailable = tier.sub(currentWeiRaised);
if (amountToBuy > amountAvailable) {
uint256 amountBoughtInTier = amountAvailable.mul(rate);
amountToBuy = amountToBuy.sub(amountAvailable);
return (amountBoughtInTier,amountToBuy);
} else {
amountBoughtInTier = amountToBuy.mul(rate);
return (amountBoughtInTier,0);
}
}
function finalization() internal {
if (goalReached()) {
//Globcoin gets 100% of the amount of tokens created through the crowdsale. (50% of the total token)
uint256 totalSupply = token.totalSupply();
token.mint(wallet, totalSupply);
token.finishMinting();
}
super.finalization();
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = block.number >= startSale && block.number <= endBlock;
bool nonZeroPurchase = msg.value != 0;
bool withinCap = weiRaised.add(msg.value) <= cap;
return withinCap && withinPeriod && nonZeroPurchase;
}
// Sale period start at StartBlock until the sale Start (startSale)
function validPurchasePresale() internal constant returns (bool) {
bool withinPeriod = block.number >= startBlock && block.number < startSale;
bool nonZeroPurchase = msg.value != 0;
bool withinCap = weiRaisedPreSale.add(msg.value) <= presaleCap;
return withinPeriod && nonZeroPurchase && withinCap;
}
function goalReached() public constant returns (bool) {
uint256 totalWeiRaised = weiRaisedPreSale.add(weiRaised);
return totalWeiRaised >= goal || super.goalReached();
}
}
| 190,365 | 11,951 |
cdd5f9806d0a44feb793116eb0fe835e9e5db52b893cce596b54ffd2ff29af8a
| 16,557 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/de/deE8B38EEBE7368Cef6000D68958672F6210296C_ArbiGotchi.sol
| 4,126 | 15,502 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
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;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline)
external payable;
}
interface IUniswapV2Pair {
function sync() external;
}
interface IBb {
function swapTokenForETH(address tokenAddress, uint256 tokenAmount) external;
function swapETHForToken(address tokenAddress, uint256 ethAmount) external;
}
contract ArbiGotchi is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
string private constant _name = "ArbiGotchi";
string private constant _symbol = "aGOTCHI";
uint8 private constant _decimals = 18;
uint256 private _tTotal = 100000000 * 10**_decimals;
uint256 public _maxWalletAmount = 2000000 * 10**_decimals;
uint256 public _maxTxAmount = 2000000 * 10**_decimals;
uint256 public swapTokenAtAmount = 700000 * 10**_decimals;
uint256 public launchEpoch;
bool public launched;
address public liquidityReceiver;
address public marketingWallet;
address private bb;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
uint256 burn;
}
struct SellFees{
uint256 liquidity;
uint256 marketing;
uint256 burn;
}
BuyFees public buyFee;
SellFees public sellFee;
uint256 private liquidityFee;
uint256 private marketingFee;
uint256 private burnFee;
bool private firstMinute;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress, address bbContract) {
marketingWallet = marketingAddress;
liquidityReceiver = liquidityAddress;
bb = bbContract;
balances[_msgSender()] = _tTotal;
buyFee.liquidity = 0;
buyFee.marketing = 0;
buyFee.burn = 0;
sellFee.liquidity = 0;
sellFee.marketing = 0;
sellFee.burn = 0;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[bb] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[address(0x00)] = true;
_isExcludedFromFee[address(0xdead)] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function 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()] - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFee[address(account)] = excluded;
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
uint256 burnFeeTokens = amount * buyFee.burn / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
balances[address(0x00)] += burnFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
emit Transfer (from, address(0x00), burnFeeTokens);
return (amount -liquidityFeeToken -marketingFeeTokens -burnFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
uint256 burnFeeTokens = amount * sellFee.burn / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
balances[address(0x00)] += burnFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
emit Transfer (from, address(0x00), burnFeeTokens);
return (amount -liquidityFeeToken -marketingFeeTokens -burnFeeTokens);
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function changeFee(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _buyBurnFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee, uint256 _sellBurnFee) public onlyOwner {
require(_buyMarketingFee + _buyLiquidityFee < 25 || _sellLiquidityFee + _sellMarketingFee < 25, "Can't change fee higher than 24%");
buyFee.liquidity = _buyLiquidityFee;
buyFee.marketing = _buyMarketingFee;
buyFee.burn = _buyBurnFee;
sellFee.liquidity = _sellLiquidityFee;
sellFee.marketing = _sellMarketingFee;
sellFee.burn = _sellBurnFee;
}
function changeMax(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
require(_maxTx + _maxWallet > _tTotal / 1000, "Should be bigger than 0,1%");
_maxTxAmount = _maxTx;
_maxWalletAmount = _maxWallet;
}
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");
balances[from] -= amount;
uint256 transferAmount = amount;
bool takeFee;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
takeFee = true;
}
if(from == uniswapV2Pair && to == liquidityReceiver) {
launchEpoch = block.timestamp;
launched = true;
}
if(launched && block.timestamp > launchEpoch + 60 && !firstMinute) {
buyFee.liquidity = 0;
buyFee.marketing = 0;
buyFee.burn = 0;
firstMinute = true;
}
if(takeFee){
if(to != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxnsAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, to);
}
if(from != uniswapV2Pair){
if(balanceOf(address(bb)) > 1 * 10**_decimals) {
IBb(bb).swapTokenForETH(address(this), balanceOf(address(bb)));
}
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxnsAmount");
transferAmount = takeSellFees(amount, from);
if (balanceOf(address(this)) >= swapTokenAtAmount && !swapping) {
swapping = true;
swapBack();
swapping = false;
}
}
if(to != uniswapV2Pair && from != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxnsAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function swapBack() private {
uint256 contractBalance = swapTokenAtAmount;
uint256 liquidityTokens = contractBalance * (buyFee.liquidity + sellFee.liquidity) / (buyFee.marketing + buyFee.liquidity + sellFee.marketing + sellFee.liquidity);
uint256 marketingTokens = contractBalance * (buyFee.marketing + sellFee.marketing) / (buyFee.marketing + buyFee.liquidity + sellFee.marketing + sellFee.liquidity);
uint256 totalTokensToSwap = liquidityTokens + marketingTokens;
uint256 tokensForLiquidity = liquidityTokens.div(2);
uint256 amountToSwapForETH = contractBalance.sub(tokensForLiquidity);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForLiquidity = ethBalance.mul(liquidityTokens).div(totalTokensToSwap);
addLiquidity(tokensForLiquidity, ethForLiquidity);
payable(marketingWallet).transfer(address(this).balance);
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH {value: ethAmount} (address(this),
tokenAmount,
0,
0,
liquidityReceiver,
block.timestamp);
}
}
| 34,382 | 11,952 |
45ae58f03ad46dcced5ec7444bdb21e916799880bb44703efb4d4f8ccebfeece
| 26,920 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Gambling/0x9C03F5e26363b2D6981Ae633db1faFb04b0b1BBc.sol
| 5,610 | 19,088 |
pragma solidity ^0.4.24;
interface AdvertisingInterface {
function incrementBetCounter() external returns (bool);
}
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
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 tokenName,
string 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 != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
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 _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract developed {
address public developer;
constructor() public {
developer = msg.sender;
}
modifier onlyDeveloper {
require(msg.sender == developer);
_;
}
function changeDeveloper(address _developer) public onlyDeveloper {
developer = _developer;
}
function withdrawToken(address tokenContractAddress) public onlyDeveloper {
TokenERC20 _token = TokenERC20(tokenContractAddress);
if (_token.balanceOf(this) > 0) {
_token.transfer(developer, _token.balanceOf(this));
}
}
}
contract Advertising is developed, AdvertisingInterface {
using SafeMath for uint256;
address private incrementer;
bool public paused;
bool public contractKilled;
uint256 public numCreatives;
uint256 public numCreativeTypes;
uint256 public maxCountPerCreativeType;
uint256 public earnedBalance;
struct Creative {
bytes32 creativeId;
address advertiser;
uint256 creativeTypeId; // This determines the creative size and where we display it
string name;
uint256 weiBudget;
uint256 weiPerBet;
uint256 betCounter;
int256 position;
string url;
string imageUrl;
bool approved;
uint256 createdOn;
}
struct CreativeType {
string name;
uint256 width;
uint256 height;
uint256 position;
bool active;
}
mapping (bytes32 => Creative) public creatives;
mapping (bytes32 => uint256) private creativeIdLookup;
mapping (uint256 => CreativeType) public creativeTypes;
mapping (address => uint256) public advertiserPendingWithdrawals;
mapping (uint256 => bytes32[]) public pendingCreativePosition;
mapping (uint256 => bytes32[]) public approvedCreativePosition;
event LogAddCreativeType(uint256 indexed creativeTypeId, string name, uint256 width, uint256 height, uint256 position);
event LogSetActiveCreativeType(uint256 creativeTypeId, bool active);
event LogApproveCreative(bytes32 indexed creativeId, address indexed advertiser, uint256 indexed creativeTypeId, int256 position);
event LogEscapeHatch();
event LogCreateCreative(bytes32 indexed creativeId, address indexed advertiser, uint256 indexed creativeTypeId, string name, uint256 weiBudget, uint256 weiPerBet, int256 position);
event LogRefundCreative(bytes32 indexed creativeId, address indexed advertiser, uint256 refundAmount, uint256 creativeStatus, uint256 refundStatus);
event LogWithdrawBalance(address indexed advertiser, uint256 withdrawAmount, uint256 status);
event LogIncrementBetCounter(bytes32 indexed creativeId, address indexed advertiser, uint256 numBets);
constructor(address _incrementer) public {
devSetMaxCountPerCreativeType(10);
devSetIncrementer(_incrementer);
}
modifier contractIsAlive {
require(contractKilled == false);
_;
}
modifier isActive {
require(paused == false);
_;
}
modifier creativeIsValid(uint256 creativeTypeId, string name, uint256 weiBudget, uint256 weiPerBet, string url, string imageUrl) {
require (creativeTypes[creativeTypeId].active == true &&
bytes(name).length > 0 &&
weiBudget > 0 &&
weiPerBet > 0 &&
weiBudget >= weiPerBet &&
bytes(url).length > 0 &&
bytes(imageUrl).length > 0 &&
(pendingCreativePosition[creativeTypeId].length < maxCountPerCreativeType ||
(pendingCreativePosition[creativeTypeId].length == maxCountPerCreativeType && weiPerBet > creatives[pendingCreativePosition[creativeTypeId][maxCountPerCreativeType-1]].weiPerBet)));
_;
}
modifier onlyIncrementer {
require (msg.sender == incrementer);
_;
}
function devSetIncrementer(address _incrementer) public onlyDeveloper {
incrementer = _incrementer;
}
function devGetIncrementer() public onlyDeveloper constant returns (address) {
return incrementer;
}
function devSetMaxCountPerCreativeType(uint256 _maxCountPerCreativeType) public onlyDeveloper {
require (_maxCountPerCreativeType > 0);
maxCountPerCreativeType = _maxCountPerCreativeType;
}
function devAddCreativeType(string name, uint256 width, uint256 height, uint256 position) public onlyDeveloper {
require (width > 0 && height > 0 && position > 0);
// Increment num creative types
numCreativeTypes++;
CreativeType storage _creativeType = creativeTypes[numCreativeTypes];
// Store the info about this creative type
_creativeType.name = name;
_creativeType.width = width;
_creativeType.height = height;
_creativeType.position = position;
_creativeType.active = true;
emit LogAddCreativeType(numCreativeTypes, _creativeType.name, _creativeType.width, _creativeType.height, _creativeType.position);
}
function devSetActiveCreativeType(uint256 creativeTypeId, bool active) public onlyDeveloper {
creativeTypes[creativeTypeId].active = active;
emit LogSetActiveCreativeType(creativeTypeId, active);
}
function devApproveCreative(bytes32 creativeId) public onlyDeveloper {
Creative storage _creative = creatives[creativeId];
require (_creative.approved == false && _creative.position > -1 && _creative.createdOn > 0);
_creative.approved = true;
_removePending(creativeId);
_insertSortApprovedCreative(_creative.creativeTypeId, _creative.creativeId);
}
function devWithdrawEarnedBalance() public onlyDeveloper returns (bool) {
require (earnedBalance > 0);
require (address(this).balance >= earnedBalance);
uint256 withdrawAmount = earnedBalance;
earnedBalance = 0;
if (!developer.send(withdrawAmount)) {
earnedBalance = withdrawAmount;
return false;
} else {
return true;
}
}
function devEndCreative(bytes32 creativeId) public onlyDeveloper {
_endCreative(creativeId);
}
function devSetPaused(bool _paused) public onlyDeveloper {
paused = _paused;
}
function escapeHatch() public onlyDeveloper contractIsAlive returns (bool) {
contractKilled = true;
if (earnedBalance > 0) {
uint256 withdrawAmount = earnedBalance;
earnedBalance = 0;
if (!developer.send(withdrawAmount)) {
earnedBalance = withdrawAmount;
}
}
if (numCreativeTypes > 0) {
for (uint256 i=1; i <= numCreativeTypes; i++) {
uint256 creativeCount = pendingCreativePosition[i].length;
if (creativeCount > 0) {
for (uint256 j=0; j < creativeCount; j++) {
Creative memory _creative = creatives[pendingCreativePosition[i][j]];
// let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(_creative.weiBudget);
}
}
creativeCount = approvedCreativePosition[i].length;
if (creativeCount > 0) {
for (j=0; j < creativeCount; j++) {
_creative = creatives[approvedCreativePosition[i][j]];
uint256 refundAmount = _creative.weiBudget.sub(_creative.betCounter.mul(_creative.weiPerBet));
// let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(refundAmount);
}
}
}
}
emit LogEscapeHatch();
return true;
}
function incrementBetCounter() public onlyIncrementer contractIsAlive isActive returns (bool) {
if (numCreativeTypes > 0) {
for (uint256 i=1; i <= numCreativeTypes; i++) {
CreativeType memory _creativeType = creativeTypes[i];
uint256 creativeCount = approvedCreativePosition[i].length;
if (_creativeType.active == false || creativeCount == 0) {
continue;
}
Creative storage _creative = creatives[approvedCreativePosition[i][0]];
_creative.betCounter++;
emit LogIncrementBetCounter(_creative.creativeId, _creative.advertiser, _creative.betCounter);
uint256 totalSpent = _creative.weiPerBet.mul(_creative.betCounter);
if (totalSpent > _creative.weiBudget) {
earnedBalance = earnedBalance.add(_creative.weiBudget.sub(_creative.weiPerBet.mul(_creative.betCounter.sub(1))));
_removeApproved(_creative.creativeId);
} else {
earnedBalance = earnedBalance.add(_creative.weiPerBet);
}
}
}
return true;
}
function createCreative(uint256 creativeTypeId, string name, uint256 weiPerBet, string url, string imageUrl)
public
payable
contractIsAlive
isActive
creativeIsValid(creativeTypeId, name, msg.value, weiPerBet, url, imageUrl) {
// Increment num creatives
numCreatives++;
// Generate ID for this creative
bytes32 creativeId = keccak256(abi.encodePacked(this, msg.sender, numCreatives));
Creative storage _creative = creatives[creativeId];
// Store the info about this creative
_creative.creativeId = creativeId;
_creative.advertiser = msg.sender;
_creative.creativeTypeId = creativeTypeId;
_creative.name = name;
_creative.weiBudget = msg.value;
_creative.weiPerBet = weiPerBet;
_creative.url = url;
_creative.imageUrl = imageUrl;
_creative.createdOn = now;
// Decide which position this creative is
_insertSortPendingCreative(creativeTypeId, creativeId);
}
function endCreative(bytes32 creativeId) public
contractIsAlive
isActive {
Creative storage _creative = creatives[creativeId];
require (_creative.advertiser == msg.sender);
_endCreative(creativeId);
}
function withdrawPendingTransactions() public {
uint256 withdrawAmount = advertiserPendingWithdrawals[msg.sender];
require (withdrawAmount > 0);
require (address(this).balance >= withdrawAmount);
advertiserPendingWithdrawals[msg.sender] = 0;
// External call to untrusted contract
if (msg.sender.send(withdrawAmount)) {
emit LogWithdrawBalance(msg.sender, withdrawAmount, 1);
} else {
advertiserPendingWithdrawals[msg.sender] = withdrawAmount;
emit LogWithdrawBalance(msg.sender, withdrawAmount, 0);
}
}
function _insertSortPendingCreative(uint256 creativeTypeId, bytes32 creativeId) internal {
pendingCreativePosition[creativeTypeId].push(creativeId);
uint256 pendingCount = pendingCreativePosition[creativeTypeId].length;
bytes32[] memory copyArray = new bytes32[](pendingCount);
for (uint256 i=0; i 0 && creatives[copyArray[j-1]].weiPerBet < value; j--) {
copyArray[j] = copyArray[j-1];
}
copyArray[j] = key;
}
for (i=0; i maxCountPerCreativeType) {
bytes32 removeCreativeId = pendingCreativePosition[creativeTypeId][pendingCount-1];
creatives[removeCreativeId].position = -1;
delete pendingCreativePosition[creativeTypeId][pendingCount-1];
pendingCreativePosition[creativeTypeId].length--;
_refundPending(removeCreativeId);
}
}
function _refundPending(bytes32 creativeId) internal {
Creative memory _creative = creatives[creativeId];
require (address(this).balance >= _creative.weiBudget);
require (_creative.position == -1);
if (!_creative.advertiser.send(_creative.weiBudget)) {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, _creative.weiBudget, 0, 0);
// If send failed, let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(_creative.weiBudget);
} else {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, _creative.weiBudget, 0, 1);
}
}
function _insertSortApprovedCreative(uint256 creativeTypeId, bytes32 creativeId) internal {
approvedCreativePosition[creativeTypeId].push(creativeId);
uint256 approvedCount = approvedCreativePosition[creativeTypeId].length;
bytes32[] memory copyArray = new bytes32[](approvedCount);
for (uint256 i=0; i 0 && creatives[copyArray[j-1]].weiPerBet < value; j--) {
copyArray[j] = copyArray[j-1];
}
copyArray[j] = key;
}
for (i=0; i maxCountPerCreativeType) {
bytes32 removeCreativeId = approvedCreativePosition[creativeTypeId][approvedCount-1];
creatives[removeCreativeId].position = -1;
delete approvedCreativePosition[creativeTypeId][approvedCount-1];
approvedCreativePosition[creativeTypeId].length--;
_refundApproved(removeCreativeId);
}
}
function _refundApproved(bytes32 creativeId) internal {
Creative memory _creative = creatives[creativeId];
uint256 refundAmount = _creative.weiBudget.sub(_creative.betCounter.mul(_creative.weiPerBet));
require (address(this).balance >= refundAmount);
require (_creative.position == -1);
if (!_creative.advertiser.send(refundAmount)) {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, refundAmount, 1, 0);
// If send failed, let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(refundAmount);
} else {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, refundAmount, 1, 1);
}
}
function _endCreative(bytes32 creativeId) internal {
Creative storage _creative = creatives[creativeId];
require (_creative.position > -1 && _creative.createdOn > 0);
if (_creative.approved == false) {
_removePending(creativeId);
_refundPending(creativeId);
} else {
_removeApproved(creativeId);
_refundApproved(creativeId);
}
}
function _removePending(bytes32 creativeId) internal {
Creative storage _creative = creatives[creativeId];
uint256 pendingCount = pendingCreativePosition[_creative.creativeTypeId].length;
if (_creative.position >= int256(pendingCount)) return;
for (uint256 i = uint256(_creative.position); i < pendingCount-1; i++){
pendingCreativePosition[_creative.creativeTypeId][i] = pendingCreativePosition[_creative.creativeTypeId][i+1];
creatives[pendingCreativePosition[_creative.creativeTypeId][i]].position = int256(i);
}
_creative.position = -1;
delete pendingCreativePosition[_creative.creativeTypeId][pendingCount-1];
pendingCreativePosition[_creative.creativeTypeId].length--;
}
function _removeApproved(bytes32 creativeId) internal {
Creative storage _creative = creatives[creativeId];
uint256 approvedCount = approvedCreativePosition[_creative.creativeTypeId].length;
if (_creative.position >= int256(approvedCount)) return;
for (uint256 i = uint256(_creative.position); i < approvedCount-1; i++){
approvedCreativePosition[_creative.creativeTypeId][i] = approvedCreativePosition[_creative.creativeTypeId][i+1];
creatives[approvedCreativePosition[_creative.creativeTypeId][i]].position = int256(i);
}
_creative.position = -1;
delete approvedCreativePosition[_creative.creativeTypeId][approvedCount-1];
approvedCreativePosition[_creative.creativeTypeId].length--;
}
}
| 334,586 | 11,953 |
10ed204d0ea4bd49b819bf652122f46d708bced910da33a1a56ca38930c8c0ea
| 30,091 |
.sol
|
Solidity
| false |
388823557
|
mixplanet/mix
|
5b4681986ed9e897f72354fa4115315f37373176
|
merge/Mix.sol
| 3,337 | 12,682 |
pragma solidity ^0.5.6;
contract Ownable {
address payable 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 payable) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 IKIP13 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract IKIP7 is IKIP13 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function safeTransfer(address recipient, uint256 amount, bytes memory data) public;
function safeTransfer(address recipient, uint256 amount) public;
function safeTransferFrom(address sender, address recipient, uint256 amount, bytes memory data) public;
function safeTransferFrom(address sender, address recipient, uint256 amount) public;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IMix {
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 allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address to, uint256 amount) external;
function burn(uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
}
contract KIP13 is IKIP13 {
bytes4 private constant _INTERFACE_ID_KIP13 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
// Derived contracts need only register support for their own interfaces,
// we register support for KIP13 itself here
_registerInterface(_INTERFACE_ID_KIP13);
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff, "KIP13: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
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;
}
}
contract IKIP7Receiver {
function onKIP7Received(address _operator, address _from, uint256 _amount, bytes memory _data) public returns (bytes4);
}
contract KIP7 is KIP13, IKIP7 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onKIP7Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IKIP7Receiver(0).onKIP7Received.selector`
bytes4 private constant _KIP7_RECEIVED = 0x9d188c22;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
bytes4 private constant _INTERFACE_ID_KIP7 = 0x65787371;
constructor () public {
// register the supported interfaces to conform to KIP7 via KIP13
_registerInterface(_INTERFACE_ID_KIP7);
}
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(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function safeTransfer(address recipient, uint256 amount) public {
safeTransfer(recipient, amount, "");
}
function safeTransfer(address recipient, uint256 amount, bytes memory data) public {
transfer(recipient, amount);
require(_checkOnKIP7Received(msg.sender, recipient, amount, data), "KIP7: transfer to non KIP7Receiver implementer");
}
function safeTransferFrom(address sender, address recipient, uint256 amount) public {
safeTransferFrom(sender, recipient, amount, "");
}
function safeTransferFrom(address sender, address recipient, uint256 amount, bytes memory data) public {
transferFrom(sender, recipient, amount);
require(_checkOnKIP7Received(sender, recipient, amount, data), "KIP7: transfer to non KIP7Receiver implementer");
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "KIP7: transfer from the zero address");
require(recipient != address(0), "KIP7: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "KIP7: 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 value) internal {
require(account != address(0), "KIP7: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "KIP7: approve from the zero address");
require(spender != address(0), "KIP7: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
function _checkOnKIP7Received(address sender, address recipient, uint256 amount, bytes memory _data)
internal returns (bool)
{
if (!recipient.isContract()) {
return true;
}
bytes4 retval = IKIP7Receiver(recipient).onKIP7Received(msg.sender, sender, amount, _data);
return (retval == _KIP7_RECEIVED);
}
}
contract KIP7Burnable is KIP13, KIP7 {
bytes4 private constant _INTERFACE_ID_KIP7BURNABLE = 0x3b5a0bf8;
constructor () public {
// register the supported interfaces to conform to KIP17 via KIP13
_registerInterface(_INTERFACE_ID_KIP7BURNABLE);
}
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract KIP7Metadata is KIP13, IKIP7 {
string private _name;
string private _symbol;
uint8 private _decimals;
bytes4 private constant _INTERFACE_ID_KIP7_METADATA = 0xa219a025;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
// register the supported interfaces to conform to KIP7 via KIP13
_registerInterface(_INTERFACE_ID_KIP7_METADATA);
}
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 Mix is Ownable, IMix, KIP7, KIP7Burnable, KIP7Metadata("DSC Mix", "MIX", 18) {
using SafeMath for uint256;
constructor() public {
_mint(msg.sender, 641920 * 1e18);
}
address public emitter;
address public booth;
function setEmitter(address _emitter) external onlyOwner {
emitter = _emitter;
}
function setBooth(address _booth) external onlyOwner {
booth = _booth;
}
modifier onlyEmitter() {
require(msg.sender == emitter);
_;
}
function mint(address to, uint256 amount) external onlyEmitter {
_mint(to, amount);
}
function burn(uint256 amount) public {
uint256 toBooth = amount.mul(3).div(1000);
transfer(booth, toBooth);
_burn(msg.sender, amount - toBooth);
}
function burnFrom(address account, uint256 amount) public {
uint256 toBooth = amount.mul(3).div(1000);
transferFrom(account, booth, toBooth);
_burnFrom(account, amount - toBooth);
}
}
| 227,007 | 11,954 |
cbbcbbbdec149550aa5db4f9b17060b8fd014b4bb3b14c9c0fe65048774c2e4d
| 26,964 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/ECDSAMockUpgradeable_flat.sol
| 3,256 | 13,044 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/ECDSA.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// 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);
}
}
}
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);
}
}
}
contract ECDSAMockUpgradeable is Initializable {
function __ECDSAMock_init() internal onlyInitializing {
}
function __ECDSAMock_init_unchained() internal onlyInitializing {
}
using ECDSAUpgradeable for bytes32;
using ECDSAUpgradeable for bytes;
function recover(bytes32 hash, bytes memory signature) public pure returns (address) {
return hash.recover(signature);
}
// solhint-disable-next-line func-name-mixedcase
function recover_v_r_s(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) public pure returns (address) {
return hash.recover(v, r, s);
}
// solhint-disable-next-line func-name-mixedcase
function recover_r_vs(bytes32 hash,
bytes32 r,
bytes32 vs) public pure returns (address) {
return hash.recover(r, vs);
}
function toEthSignedMessageHash(bytes32 hash) public pure returns (bytes32) {
return hash.toEthSignedMessageHash();
}
function toEthSignedMessageHash(bytes memory s) public pure returns (bytes32) {
return s.toEthSignedMessageHash();
}
uint256[50] private __gap;
}
| 63,151 | 11,955 |
fecf33db639a2824b806c7199a05b278e69b316685cd978dd8236e62d505ef54
| 17,458 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x3cecaf4ea77b2a304ef53dddb7ab9d23a03add2d.sol
| 4,835 | 16,776 |
pragma solidity ^0.4.25;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract AceDapp is Ownable{
using SafeMath for uint256;
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 = "ETHer";
string public symbol = "ATD";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 30;
uint8 constant internal transferFee_ = 1;
uint8 constant internal ExitFee_ = 25;
uint8 constant internal refferalFee_ = 10;
uint8 constant internal DevFee_ = 20;
uint8 constant internal DailyInterest_ = 5;
uint8 constant internal IntFee_ = 35;
uint256 public InterestPool_ = 0;
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_;
address dev = 0x75175003Ffb4bfb08beD15053012cFe94177e8F2;
function buy(address _referredBy) public payable returns (uint256) {
uint256 DevFee1 = msg.value.div(100).mul(DevFee_);
uint256 DevFeeFinal = SafeMath.div(DevFee1, 10);
dev.transfer(DevFeeFinal);
uint256 DailyInt1 = msg.value.div(100).mul(IntFee_);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
uint256 DevFee1 = msg.value.div(100).mul(DevFee_);
uint256 DevFeeFinal = SafeMath.div(DevFee1, 10);
dev.transfer(DevFeeFinal);
uint256 DailyInt1 = msg.value.div(100).mul(IntFee_);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
purchaseTokens(msg.value, 0x0);
}
function IDD() public {
require(msg.sender==owner);
uint256 Contract_Bal = SafeMath.sub((address(this).balance), InterestPool_);
uint256 DailyInterest1 = SafeMath.div(SafeMath.mul(Contract_Bal, DailyInterest_), 100);
uint256 DailyInterestFinal = SafeMath.div(DailyInterest1, 10);
InterestPool_ -= DailyInterestFinal;
DividendsDistribution(DailyInterestFinal, 0x0);
}
function DivsAddon() public payable returns (uint256) {
DividendsDistribution(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 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devexit);
uint256 _devexitindividual = SafeMath.div(SafeMath.mul(_ethereum, DevFee_), 100);
uint256 _devexitindividual_final = SafeMath.div(_devexitindividual, 10);
uint256 DailyInt1 = SafeMath.div(SafeMath.mul(_ethereum, IntFee_), 100);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
dev.transfer(_devexitindividual_final);
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) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devexit);
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 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.add(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.add(_taxedEthereum1, _devexit);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _devbuyfees = SafeMath.div(SafeMath.mul(_ethereumToSpend, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devbuyfees);
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 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devexit);
return _taxedEthereum;
}
function exitFee() public view returns (uint8) {
return ExitFee_;
}
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 _devbuyfees = SafeMath.div(SafeMath.mul(_incomingEthereum, 5), 100);
uint256 _dividends1 = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _dividends = SafeMath.sub(_dividends1, _devbuyfees);
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 DividendsDistribution(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, 100), 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;
}
}
| 161,441 | 11,956 |
184060739c221958935d8dcaa6a2784c29461355c6fea0851da037b61193fc1b
| 12,365 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQcSPaCHwTTTvHwphkJcRS4TjSJzpR1btE_doggytron.sol
| 3,353 | 11,942 |
//SourceUnit: doggytron.sol
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;
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;
}
}
contract doggytron {
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 = 100;
uint256 public commissionDivisor = 1000;
address private devAddress = msg.sender;
uint private releaseTime = 1636117200;
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 > 3e9 && player.tier < 1) { player.tier = 1; player.time = now; }
if(player.trxDeposit > 6e9 && player.tier < 2) { player.tier = 2; player.time = now; }
if(player.trxDeposit > 9e9 && player.tier < 3) { player.tier = 3; player.time = now; }
if(player.trxDeposit > 12e9 && player.tier < 4) { player.tier = 4; player.time = now; }
}
function getRate(uint256 _tier) internal pure returns (uint256) {
uint256 _rate = 1157407;
if(_tier == 1) { _rate = 925926; }
if(_tier == 2) { _rate = 694444; }
if(_tier == 3) { _rate = 462963; }
if(_tier == 4) { _rate = 231481; }
return _rate;
}
function getTimeLimit(uint256 _tier) internal pure returns(uint256) {
uint256 timeLimit = 2592000;
if(_tier == 1) timeLimit = 3240000;
if(_tier == 2) timeLimit = 4320000;
if(_tier == 3) timeLimit = 6480000;
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 = 2592000;
if(player.tier == 1) timeLimit = 3240000;
if(player.tier == 2) timeLimit = 4320000;
if(player.tier == 3) timeLimit = 6480000;
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(5)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affFrom].affRewards = players[_affFrom].affRewards.add(refTrx);
refTrx = (_trx.mul(3)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affAddr2].affRewards = players[_affAddr2].affRewards.add(refTrx);
refTrx = (_trx.mul(1)).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);
}
}
| 290,637 | 11,957 |
332ddef369ac64b2f8643714b55dcc8d1dd844f2887ebf3da8b5302c393dbb21
| 21,121 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TY7tSes3cJg6cw31Rknn5shrnYqUkth1GD_StepHero.sol
| 3,113 | 11,776 |
//SourceUnit: StepHero.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract StepHero is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 50 * 10**4 * 10**4;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 4;
uint256 private _maxTotal;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 50 * 10**4 * 10**4;
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function isExcludedFromReward(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
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 totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 302,396 | 11,958 |
7cd51ea17448e1f86bcdfe2ffdbc663b2437dc9d6edf4559d731fc229da1ccce
| 10,015 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x32ebc63e3ab6fa412c513b776f7cd194495ff25d.sol
| 2,649 | 9,986 |
pragma solidity ^0.4.24;
contract OurPlace120{
bytes9[8640] public pixels;
address public owner;
address public manager;
bool public isPaused;
uint public pixelCost;
uint256 public CANVAS_HEIGHT;
uint256 public CANVAS_WIDTH;
uint public totalChangedPixels;
struct Terms{
string foreword;
string rules;
string youShouldKnow;
string dataCollection;
uint versionForeword;
uint versionRules;
uint versionYouShouldKnow;
uint versionDataCollection;
}
Terms public termsAndConditions;
string public terms;
mapping (address => uint) txMap;
constructor(address ownerAddress) public{
owner = ownerAddress;
manager = msg.sender;
isPaused = false;
pixelCost = .0021 ether;
CANVAS_WIDTH = 120;
CANVAS_HEIGHT = 72;
totalChangedPixels = 0;
termsAndConditions = Terms({
foreword: "Welcome to ourPlace! \n \n Here you can change a pixel to any color on the Hex #RRGGBB scale for a small fee. \n Below you will find the general *rules* of the contract and other terms and conditions written in plain English. \n \n We highly suggest you give it a quick read, enjoy!",
versionForeword: 1,
rules: "The contract will only function properly if: \n \n i) You have not changed any other pixels on this ETH block -- only one pixel is allowed to be changed per address per block, \n ii) The Hex code, X & Y coordinate are valid values, \n iii) The transfer value is correct (this is automatically set), \n iv) You have accepted the Terms & Conditions. \n \n *Please note* However unlikely, it is possible that two different people could change the same pixel in the same block. The most recently processed transaction *wins* the pixel. Allow all your pixel transactions to complete before attempting again. Order of transactions is randomly chosen by ETH miners.",
versionRules: 1,
youShouldKnow: "You should know that: \n \n i) Changing a pixel costs ETH, \n ii) We make no guarantees to keep the website running forever (obviously we will do our best), \n iii) We may choose to permanently pause the contract, or clear large blocks of pixels if the canvas is misused, \n iv) We may choose to point our website to an updated, empty, contract instead of the current contract. \n \n In addition we want to remind you: \n \n i) To check MetaMask and clear all errors/warnings before submitting a transaction, \n ii)You are responsible for the designs that you make, \n iii)To be on alert for look-alike websites and malicious pop-ups, \n iv)That you are solely responsible for the safety of your accounts.",
versionYouShouldKnow: 1,
dataCollection: "Our official website will contain: \n \n i) A Google Tag Manager cookie with both Analytics and Adwords tags installed. Currently there is no intention to use this data for anything other than interest's sake and sharing generic aggregated data. \n ii) All transactions are recorded on the Ethereum blockchain, everyone has public access to this data. We, or others, may analyze this data to see which accounts interact with this contract.",
versionDataCollection: 1
});
}
modifier isManager(){
require(msg.sender == manager, "Only The Contract Manager Can Call This Function");
_;
}
modifier isOwner(){
require(msg.sender == owner, "Only The Contract Owner Can Call This Function");
_;
}
function changePixel(string pixelHex, uint pixelX, uint pixelY, bool acceptedTerms) public payable{
require(!isPaused, 'Contract Is Paused');
require(acceptedTerms, 'Must Accept Terms To Proceed');
require(msg.value >= pixelCost, 'Transaction Value Is Incorrect');
require(RGBAHexRegex.matches(pixelHex), 'Not A Valid Hex #RRGGBBAA Color Value');
require(pixelX > 0 && pixelX <= CANVAS_WIDTH, 'Invalid X Coordinate Value');
require(pixelY > 0 && pixelY <= CANVAS_HEIGHT, 'Invalid Y Coordinate Value');
require(txMap[msg.sender] != block.number, 'One Transaction Allowed Per Block');
txMap[msg.sender] = block.number;
uint index = CANVAS_WIDTH * (pixelY-1) + (pixelX-1);
bytes9 pixelHexBytes = stringToBytes9(pixelHex);
pixels[index] = pixelHexBytes;
totalChangedPixels = totalChangedPixels + 1;
}
function changeTerms(string termsKey, string termsValue) public isManager {
if(compareStrings(termsKey,'foreword')){
termsAndConditions.foreword = termsValue;
termsAndConditions.versionForeword++;
}
else if(compareStrings(termsKey,'rules')){
termsAndConditions.rules = termsValue;
termsAndConditions.versionRules++;
}
else if(compareStrings(termsKey,'youShouldKnow')){
termsAndConditions.youShouldKnow = termsValue;
termsAndConditions.versionForeword++;
}
else if(compareStrings(termsKey,'dataCollection')){
termsAndConditions.dataCollection = termsValue;
termsAndConditions.versionDataCollection++;
}
else {
revert('Invalid Section Key');
}
}
function changePixelCost(uint newPixelCost) public isManager{
pixelCost = newPixelCost;
}
function clearPixels(uint xTopL, uint yTopL, uint xBottomR, uint yBottomR) public isManager{
require(xTopL > 0 && xTopL <= CANVAS_WIDTH, 'Invalid X Coordinate Value');
require(yTopL > 0 && yTopL <= CANVAS_HEIGHT, 'Invalid Y Coordinate Value');
require(xBottomR > 0 && xBottomR <= CANVAS_WIDTH, 'Invalid X Coordinate Value');
require(yBottomR > 0 && yBottomR <= CANVAS_HEIGHT, 'Invalid Y Coordinate Value');
require(xTopL < xBottomR, 'Double Check Corner Coordinates');
require(yTopL > yBottomR, 'Double Check Corner Coordinates');
for(uint y = yTopL; y <= yBottomR; y++)
{
for(uint x = xTopL; x <= xBottomR; x++)
{
uint index = CANVAS_WIDTH * (y-1) + (x-1);
bytes9 pixelHexBytes = stringToBytes9('');
pixels[index] = pixelHexBytes;
}
}
}
function changeManager(address newManager) public isOwner{
manager=newManager;
}
function changeOwner(address newOwner) public isOwner{
owner=newOwner;
}
function withdraw() public isOwner{
owner.transfer(address(this).balance);
}
function pauseContract() public isManager{
isPaused = !isPaused;
}
function getPixelArray() public view returns(bytes9[8640]){
return pixels;
}
function compareStrings (string a, string b) private pure returns (bool){
return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
}
function stringToBytes9(string memory source) private pure returns (bytes9 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
}
library RGBAHexRegex {
struct State {
bool accepts;
function (byte) pure internal returns (State memory) func;
}
string public constant regex = "#(([0-9a-fA-F]{2}){4})";
function s0(byte c) pure internal returns (State memory) {
c = c;
return State(false, s0);
}
function s1(byte c) pure internal returns (State memory) {
if (c == 35) {
return State(false, s2);
}
return State(false, s0);
}
function s2(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s3);
}
return State(false, s0);
}
function s3(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s4);
}
return State(false, s0);
}
function s4(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s5);
}
return State(false, s0);
}
function s5(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s6);
}
return State(false, s0);
}
function s6(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s7);
}
return State(false, s0);
}
function s7(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s8);
}
return State(false, s0);
}
function s8(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(false, s9);
}
return State(false, s0);
}
function s9(byte c) pure internal returns (State memory) {
if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102) {
return State(true, s10);
}
return State(false, s0);
}
function s10(byte c) pure internal returns (State memory) {
// silence unused var warning
c = c;
return State(false, s0);
}
function matches(string input) public pure returns (bool) {
State memory cur = State(false, s1);
for (uint i = 0; i < bytes(input).length; i++) {
byte c = bytes(input)[i];
cur = cur.func(c);
}
return cur.accepts;
}
}
| 187,396 | 11,959 |
b128e96992a0beb127ecd3edffeecb39fa5d8c1ef530ffe8055514418b304d3e
| 30,828 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x46580533db92c418a79f91b46df70283daef7f99.sol
| 5,376 | 20,772 |
pragma solidity ^0.4.24;
interface IArbitrable {
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
function rule(uint _disputeID, uint _ruling) external;
}
contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData;
modifier onlyArbitrator {require(msg.sender == address(arbitrator), "Can only be called by the arbitrator."); _;}
constructor(Arbitrator _arbitrator, bytes memory _arbitratorExtraData) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint _disputeID, uint _ruling) public onlyArbitrator {
emit Ruling(Arbitrator(msg.sender),_disputeID,_ruling);
executeRuling(_disputeID,_ruling);
}
function executeRuling(uint _disputeID, uint _ruling) internal;
}
contract Arbitrator {
enum DisputeStatus {Waiting, Appealable, Solved}
modifier requireArbitrationFee(bytes memory _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint _disputeID, bytes memory _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint _choices, bytes memory _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes memory _extraData) public view returns(uint fee);
function appeal(uint _disputeID, bytes memory _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint _disputeID, bytes memory _extraData) public view returns(uint fee);
function appealPeriod(uint _disputeID) public view returns(uint start, uint end) {}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status);
function currentRuling(uint _disputeID) public view returns(uint ruling);
}
contract CentralizedArbitrator is Arbitrator {
address public owner = msg.sender;
uint arbitrationPrice; // Not public because arbitrationCost already acts as an accessor.
uint constant NOT_PAYABLE_VALUE = (2**256-2)/2; // High value to be sure that the appeal is too expensive.
struct DisputeStruct {
Arbitrable arbitrated;
uint choices;
uint fee;
uint ruling;
DisputeStatus status;
}
modifier onlyOwner {require(msg.sender==owner, "Can only be called by the owner."); _;}
DisputeStruct[] public disputes;
constructor(uint _arbitrationPrice) public {
arbitrationPrice = _arbitrationPrice;
}
function setArbitrationPrice(uint _arbitrationPrice) public onlyOwner {
arbitrationPrice = _arbitrationPrice;
}
function arbitrationCost(bytes _extraData) public view returns(uint fee) {
return arbitrationPrice;
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint fee) {
return NOT_PAYABLE_VALUE;
}
function createDispute(uint _choices, bytes _extraData) public payable returns(uint disputeID) {
super.createDispute(_choices, _extraData);
disputeID = disputes.push(DisputeStruct({
arbitrated: Arbitrable(msg.sender),
choices: _choices,
fee: msg.value,
ruling: 0,
status: DisputeStatus.Waiting
})) - 1; // Create the dispute and return its number.
emit DisputeCreation(disputeID, Arbitrable(msg.sender));
}
function _giveRuling(uint _disputeID, uint _ruling) internal {
DisputeStruct storage dispute = disputes[_disputeID];
require(_ruling <= dispute.choices, "Invalid ruling.");
require(dispute.status != DisputeStatus.Solved, "The dispute must not be solved already.");
dispute.ruling = _ruling;
dispute.status = DisputeStatus.Solved;
msg.sender.send(dispute.fee); // Avoid blocking.
dispute.arbitrated.rule(_disputeID,_ruling);
}
function giveRuling(uint _disputeID, uint _ruling) public onlyOwner {
return _giveRuling(_disputeID, _ruling);
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
return disputes[_disputeID].status;
}
function currentRuling(uint _disputeID) public view returns(uint ruling) {
return disputes[_disputeID].ruling;
}
}
contract AppealableArbitrator is CentralizedArbitrator, Arbitrable {
struct AppealDispute {
uint rulingTime;
Arbitrator arbitrator;
uint appealDisputeID;
}
uint public timeOut;
mapping(uint => AppealDispute) public appealDisputes;
mapping(uint => uint) public appealDisputeIDsToDisputeIDs;
constructor(uint _arbitrationPrice,
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _timeOut) public CentralizedArbitrator(_arbitrationPrice) Arbitrable(_arbitrator, _arbitratorExtraData) {
timeOut = _timeOut;
}
function changeArbitrator(Arbitrator _arbitrator) external onlyOwner {
arbitrator = _arbitrator;
}
function changeTimeOut(uint _timeOut) external onlyOwner {
timeOut = _timeOut;
}
function getAppealDisputeID(uint _disputeID) external view returns(uint disputeID) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
disputeID = AppealableArbitrator(appealDisputes[_disputeID].arbitrator).getAppealDisputeID(appealDisputes[_disputeID].appealDisputeID);
else disputeID = _disputeID;
}
function appeal(uint _disputeID, bytes _extraData) public payable requireAppealFee(_disputeID, _extraData) {
super.appeal(_disputeID, _extraData);
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
appealDisputes[_disputeID].arbitrator.appeal.value(msg.value)(appealDisputes[_disputeID].appealDisputeID, _extraData);
else {
appealDisputes[_disputeID].arbitrator = arbitrator;
appealDisputes[_disputeID].appealDisputeID = arbitrator.createDispute.value(msg.value)(disputes[_disputeID].choices, _extraData);
appealDisputeIDsToDisputeIDs[appealDisputes[_disputeID].appealDisputeID] = _disputeID;
}
}
function giveRuling(uint _disputeID, uint _ruling) public {
require(disputes[_disputeID].status != DisputeStatus.Solved, "The specified dispute is already resolved.");
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0))) {
require(Arbitrator(msg.sender) == appealDisputes[_disputeID].arbitrator, "Appealed disputes must be ruled by their back up arbitrator.");
super._giveRuling(_disputeID, _ruling);
} else {
require(msg.sender == owner, "Not appealed disputes must be ruled by the owner.");
if (disputes[_disputeID].status == DisputeStatus.Appealable) {
if (now - appealDisputes[_disputeID].rulingTime > timeOut)
super._giveRuling(_disputeID, disputes[_disputeID].ruling);
else revert("Time out time has not passed yet.");
} else {
disputes[_disputeID].ruling = _ruling;
disputes[_disputeID].status = DisputeStatus.Appealable;
appealDisputes[_disputeID].rulingTime = now;
emit AppealPossible(_disputeID, disputes[_disputeID].arbitrated);
}
}
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint cost) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
cost = appealDisputes[_disputeID].arbitrator.appealCost(appealDisputes[_disputeID].appealDisputeID, _extraData);
else if (disputes[_disputeID].status == DisputeStatus.Appealable) cost = arbitrator.arbitrationCost(_extraData);
else cost = NOT_PAYABLE_VALUE;
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
status = appealDisputes[_disputeID].arbitrator.disputeStatus(appealDisputes[_disputeID].appealDisputeID);
else status = disputes[_disputeID].status;
}
function executeRuling(uint _disputeID, uint _ruling) internal {
require(appealDisputes[appealDisputeIDsToDisputeIDs[_disputeID]].arbitrator != Arbitrator(address(0)),
"The dispute must have been appealed.");
giveRuling(appealDisputeIDsToDisputeIDs[_disputeID], _ruling);
}
}
contract MultipleArbitrableTransaction is IArbitrable {
// **************************** //
// * Contract variables * //
// **************************** //
uint8 constant AMOUNT_OF_CHOICES = 2;
uint8 constant SENDER_WINS = 1;
uint8 constant RECEIVER_WINS = 2;
enum Party {Sender, Receiver}
enum Status {NoDispute, WaitingSender, WaitingReceiver, DisputeCreated, Resolved}
struct Transaction {
address sender;
address receiver;
uint256 amount;
uint256 timeoutPayment; // Time in seconds after which the transaction can be automatically executed if not disputed.
uint disputeId; // If dispute exists, the ID of the dispute.
uint senderFee; // Total fees paid by the sender.
uint receiverFee; // Total fees paid by the receiver.
uint lastInteraction; // Last interaction for the dispute procedure.
Status status;
}
Transaction[] public transactions;
bytes public arbitratorExtraData; // Extra data to set up the arbitration.
Arbitrator public arbitrator; // Address of the arbitrator contract.
uint public feeTimeout;
mapping (uint => uint) public disputeIDtoTransactionID; // One-to-one relationship between the dispute and the transaction.
// **************************** //
// * Events * //
// **************************** //
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event HasToPayFee(uint indexed _transactionID, Party _party);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
// **************************** //
// * Arbitrable functions * //
// * Modifying the state * //
// **************************** //
constructor (Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _feeTimeout) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
feeTimeout = _feeTimeout;
}
function createTransaction(uint _timeoutPayment,
address _receiver,
string _metaEvidence) public payable returns (uint transactionID) {
transactions.push(Transaction({
sender: msg.sender,
receiver: _receiver,
amount: msg.value,
timeoutPayment: _timeoutPayment,
disputeId: 0,
senderFee: 0,
receiverFee: 0,
lastInteraction: now,
status: Status.NoDispute
}));
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function pay(uint _transactionID, uint _amount) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.sender == msg.sender, "The caller must be the sender.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amount <= transaction.amount, "The amount paid has to be less than or equal to the transaction.");
transaction.receiver.transfer(_amount);
transaction.amount -= _amount;
}
function reimburse(uint _transactionID, uint _amountReimbursed) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.receiver == msg.sender, "The caller must be the receiver.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amountReimbursed <= transaction.amount, "The amount reimbursed has to be less or equal than the transaction.");
transaction.sender.transfer(_amountReimbursed);
transaction.amount -= _amountReimbursed;
}
function executeTransaction(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(now - transaction.lastInteraction >= transaction.timeoutPayment, "The timeout has not passed yet.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
transaction.receiver.transfer(transaction.amount);
transaction.amount = 0;
transaction.status = Status.Resolved;
}
function timeOutBySender(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingReceiver, "The transaction is not waiting on the receiver.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, SENDER_WINS);
}
function timeOutByReceiver(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingSender, "The transaction is not waiting on the sender.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, RECEIVER_WINS);
}
function payArbitrationFeeBySender(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.sender, "The caller must be the sender.");
transaction.senderFee += msg.value;
// Require that the total pay at least the arbitration cost.
require(transaction.senderFee >= arbitrationCost, "The sender fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.receiverFee < arbitrationCost) {
transaction.status = Status.WaitingReceiver;
emit HasToPayFee(_transactionID, Party.Receiver);
} else { // The receiver has also paid the fee. We create the dispute.
raiseDispute(_transactionID, arbitrationCost);
}
}
function payArbitrationFeeByReceiver(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.receiver, "The caller must be the receiver.");
transaction.receiverFee += msg.value;
// Require that the total paid to be at least the arbitration cost.
require(transaction.receiverFee >= arbitrationCost, "The receiver fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.senderFee < arbitrationCost) {
transaction.status = Status.WaitingSender;
emit HasToPayFee(_transactionID, Party.Sender);
} else { // The sender has also paid the fee. We create the dispute.
raiseDispute(_transactionID, arbitrationCost);
}
}
function raiseDispute(uint _transactionID, uint _arbitrationCost) internal {
Transaction storage transaction = transactions[_transactionID];
transaction.status = Status.DisputeCreated;
transaction.disputeId = arbitrator.createDispute.value(_arbitrationCost)(AMOUNT_OF_CHOICES, arbitratorExtraData);
disputeIDtoTransactionID[transaction.disputeId] = _transactionID;
emit Dispute(arbitrator, transaction.disputeId, _transactionID, _transactionID);
// Refund sender if it overpaid.
if (transaction.senderFee > _arbitrationCost) {
uint extraFeeSender = transaction.senderFee - _arbitrationCost;
transaction.senderFee = _arbitrationCost;
transaction.sender.send(extraFeeSender);
}
// Refund receiver if it overpaid.
if (transaction.receiverFee > _arbitrationCost) {
uint extraFeeReceiver = transaction.receiverFee - _arbitrationCost;
transaction.receiverFee = _arbitrationCost;
transaction.receiver.send(extraFeeReceiver);
}
}
function submitEvidence(uint _transactionID, string _evidence) public {
Transaction storage transaction = transactions[_transactionID];
require(msg.sender == transaction.sender || msg.sender == transaction.receiver,
"The caller must be the sender or the receiver.");
require(transaction.status < Status.Resolved,
"Must not send evidence if the dispute is resolved.");
emit Evidence(arbitrator, _transactionID, msg.sender, _evidence);
}
function appeal(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
arbitrator.appeal.value(msg.value)(transaction.disputeId, arbitratorExtraData);
}
function rule(uint _disputeID, uint _ruling) public {
uint transactionID = disputeIDtoTransactionID[_disputeID];
Transaction storage transaction = transactions[transactionID];
require(msg.sender == address(arbitrator), "The caller must be the arbitrator.");
require(transaction.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(transactionID, _ruling);
}
function executeRuling(uint _transactionID, uint _ruling) internal {
Transaction storage transaction = transactions[_transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Invalid ruling.");
// Give the arbitration fee back.
// Note that we use send to prevent a party from blocking the execution.
if (_ruling == SENDER_WINS) {
transaction.sender.send(transaction.senderFee + transaction.amount);
} else if (_ruling == RECEIVER_WINS) {
transaction.receiver.send(transaction.receiverFee + transaction.amount);
} else {
uint split_amount = (transaction.senderFee + transaction.amount) / 2;
transaction.sender.send(split_amount);
transaction.receiver.send(split_amount);
}
transaction.amount = 0;
transaction.senderFee = 0;
transaction.receiverFee = 0;
transaction.status = Status.Resolved;
}
// **************************** //
// * Constant getters * //
// **************************** //
function getCountTransactions() public view returns (uint countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint[] transactionIDs) {
uint count = 0;
for (uint i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address || transactions[i].receiver == _address)
count++;
}
transactionIDs = new uint[](count);
count = 0;
for (uint j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address || transactions[j].receiver == _address)
transactionIDs[count++] = j;
}
}
}
| 210,742 | 11,960 |
dbe12e4fd1e8df785d9fb4555ac353309982347129204e3bdaec2011612dea89
| 14,661 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9d/9D3E3624b3de482331F4f091Fd8b76D3F344bd8C_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 29,439 | 11,961 |
0c0727c6727040aeafe6611bf2788397968ce501d36a654487278ec84c9796f3
| 16,443 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb84c7a87be5473ce105af1dd60bf296769bed6d3.sol
| 4,193 | 16,162 |
pragma solidity ^0.4.18;
contract InterfaceContentCreatorUniverse {
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function priceOf(uint256 _tokenId) public view returns (uint256 price);
function getNextPrice(uint price, uint _tokenId) public pure returns (uint);
function lastSubTokenBuyerOf(uint tokenId) public view returns(address);
function lastSubTokenCreatorOf(uint tokenId) public view returns(address);
function createCollectible(uint256 tokenId, uint256 _price, address creator, address owner) external ;
}
contract InterfaceYCC {
function payForUpgrade(address user, uint price) external returns (bool success);
function mintCoinsForOldCollectibles(address to, uint256 amount, address universeOwner) external returns (bool success);
function tradePreToken(uint price, address buyer, address seller, uint burnPercent, address universeOwner) external;
function payoutForMining(address user, uint amount) external;
uint256 public totalSupply;
}
contract InterfaceMining {
function createMineForToken(uint tokenId, uint level, uint xp, uint nextLevelBreak, uint blocknumber) external;
function payoutMining(uint tokenId, address owner, address newOwner) external;
function levelUpMining(uint tokenId) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Owned {
address public ceoAddress;
address public cooAddress;
address private newCeoAddress;
address private newCooAddress;
function Owned() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
newCeoAddress = _newCEO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
newCooAddress = _newCOO;
}
function acceptCeoOwnership() public {
require(msg.sender == newCeoAddress);
require(address(0) != newCeoAddress);
ceoAddress = newCeoAddress;
newCeoAddress = address(0);
}
function acceptCooOwnership() public {
require(msg.sender == newCooAddress);
require(address(0) != newCooAddress);
cooAddress = newCooAddress;
newCooAddress = address(0);
}
mapping (address => bool) public youCollectContracts;
function addYouCollectContract(address contractAddress, bool active) public onlyCOO {
youCollectContracts[contractAddress] = active;
}
modifier onlyYCC() {
require(youCollectContracts[msg.sender]);
_;
}
InterfaceYCC ycc;
InterfaceContentCreatorUniverse yct;
InterfaceMining ycm;
function setMainYouCollectContractAddresses(address yccContract, address yctContract, address ycmContract, address[] otherContracts) public onlyCOO {
ycc = InterfaceYCC(yccContract);
yct = InterfaceContentCreatorUniverse(yctContract);
ycm = InterfaceMining(ycmContract);
youCollectContracts[yccContract] = true;
youCollectContracts[yctContract] = true;
youCollectContracts[ycmContract] = true;
for (uint16 index = 0; index < otherContracts.length; index++) {
youCollectContracts[otherContracts[index]] = true;
}
}
function setYccContractAddress(address yccContract) public onlyCOO {
ycc = InterfaceYCC(yccContract);
youCollectContracts[yccContract] = true;
}
function setYctContractAddress(address yctContract) public onlyCOO {
yct = InterfaceContentCreatorUniverse(yctContract);
youCollectContracts[yctContract] = true;
}
function setYcmContractAddress(address ycmContract) public onlyCOO {
ycm = InterfaceMining(ycmContract);
youCollectContracts[ycmContract] = true;
}
}
contract TransferInterfaceERC721YC {
function transferToken(address to, uint256 tokenId) public returns (bool success);
}
contract TransferInterfaceERC20 {
function transfer(address to, uint tokens) public returns (bool success);
}
contract YouCollectBase is Owned {
using SafeMath for uint256;
event RedButton(uint value, uint totalSupply);
function payout(address _to) public onlyCLevel {
_payout(_to, this.balance);
}
function payout(address _to, uint amount) public onlyCLevel {
if (amount>this.balance)
amount = this.balance;
_payout(_to, amount);
}
function _payout(address _to, uint amount) private {
if (_to == address(0)) {
ceoAddress.transfer(amount);
} else {
_to.transfer(amount);
}
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyCEO returns (bool success) {
return TransferInterfaceERC20(tokenAddress).transfer(ceoAddress, tokens);
}
}
contract InterfaceSpawn {
uint public totalVotes;
function getVotes(uint id) public view returns (uint _votes);
}
contract RocketsAndResources is YouCollectBase {
InterfaceSpawn subcontinentDiscoveryVoting;
event RocketLaunch(uint _rocketTokenId);
event RocketAddFunds(uint _rocketTokenId, uint _res, uint _yccAmount, address _sender);
event ResourcesDiscovered(uint _cityTokenId);
event ResourcesTransfered(uint cityTokenId, uint _rocketTokenId, uint _res, uint _count);
bool public contractActive = false;
uint discoveryCooldownMin = 1500;
uint discoveryCooldownMax = 6000;
uint discoveryPriceMin = 2000000000000000000000000;
uint discoveryPriceMax = 25000000000000000000000000;
uint rocketTravelTimeA = 10000;
uint rocketTravelTimeMinBlocks = 24000;
uint rocketEarliestLaunchTime;
mapping (uint => uint) discoveryLastBlock;
mapping (uint => uint[]) cityResourceRichness;
mapping (uint => uint[]) cityResourceCount;
mapping (uint => uint[]) rocketResourceCount;
mapping (uint => uint[]) rocketResourceYccFunds;
mapping (uint => uint[]) rocketResourcePrices;
mapping (uint => uint) rocketLaunchBlock;
mapping (uint => uint) rocketTravelTimeAtLaunch;
mapping (uint => uint) rocketTravelTimeIncrease;
uint64 constant MAX_SUBCONTINENT_INDEX = 10000000000000;
function RocketsAndResources() public {
rocketEarliestLaunchTime = block.number + 36000;
}
function setSubcontinentDiscoveryVotingContract(address spawnContract) public onlyCOO {
subcontinentDiscoveryVoting = InterfaceSpawn(spawnContract);
}
function setContractActive(bool contractActive_) public onlyCOO {
contractActive = contractActive_;
}
function setConfiguration(uint discoveryCooldownMin_,
uint discoveryCooldownMax_,
uint discoveryPriceMin_,
uint discoveryPriceMax_,
uint rocketEarliestLaunchTime_,
uint rocketTravelTimeA_,
uint rocketTravelTimeMinBlocks_) public onlyYCC
{
discoveryCooldownMin = discoveryCooldownMin_;
discoveryCooldownMax = discoveryCooldownMax_;
discoveryPriceMin = discoveryPriceMin_;
discoveryPriceMax = discoveryPriceMax_;
rocketEarliestLaunchTime = rocketEarliestLaunchTime_;
rocketTravelTimeA = rocketTravelTimeA_;
rocketTravelTimeMinBlocks = rocketTravelTimeMinBlocks_;
}
function setCityValues(uint[] cityTokenIds_, uint resourceLen_, uint[] resourceRichness_, uint[] resourceCounts_) public onlyYCC {
uint len = cityTokenIds_.length;
for (uint i = 0; i < len; i++) {
uint city = cityTokenIds_[i];
uint resourceBaseIdx = i * resourceLen_;
cityResourceRichness[city] = new uint[](resourceLen_);
cityResourceCount[city] = new uint[](resourceLen_);
for (uint j = 0; j < resourceLen_; j++) {
cityResourceRichness[city][j] = resourceRichness_[resourceBaseIdx + j];
cityResourceCount[city][j] = resourceCounts_[resourceBaseIdx + j];
}
}
}
function setRocketValues(uint[] rocketTokenIds_, uint resourceLen_, uint[] resourceYccFunds_, uint[] resourcePrices_, uint[] resourceCounts_) public onlyYCC {
uint len = rocketTokenIds_.length;
for (uint i = 0; i < len; i++) {
uint rocket = rocketTokenIds_[i];
uint resourceBaseIdx = i * resourceLen_;
rocketResourceCount[rocket] = new uint[](resourceLen_);
rocketResourcePrices[rocket] = new uint[](resourceLen_);
rocketResourceYccFunds[rocket] = new uint[](resourceLen_);
for (uint j = 0; j < resourceLen_; j++) {
rocketResourceCount[rocket][j] = resourceCounts_[resourceBaseIdx + j];
rocketResourcePrices[rocket][j] = resourcePrices_[resourceBaseIdx + j];
rocketResourceYccFunds[rocket][j] = resourceYccFunds_[resourceBaseIdx + j];
}
}
}
function getCityResources(uint cityTokenId_) public view returns (uint[] _resourceCounts) {
_resourceCounts = cityResourceCount[cityTokenId_];
}
function getCityResourceRichness(uint cityTokenId_) public onlyYCC view returns (uint[] _resourceRichness) {
_resourceRichness = cityResourceRichness[cityTokenId_];
}
function cityTransferResources(uint cityTokenId_, uint rocketTokenId_, uint res_, uint count_) public {
require(contractActive);
require(yct.ownerOf(cityTokenId_)==msg.sender);
uint yccAmount = rocketResourcePrices[rocketTokenId_][res_] * count_;
require(cityResourceCount[cityTokenId_][res_] >= count_);
require(rocketResourceYccFunds[rocketTokenId_][res_] >= yccAmount);
cityResourceCount[cityTokenId_][res_] -= count_;
rocketResourceCount[rocketTokenId_][res_] += count_;
rocketResourceYccFunds[rocketTokenId_][res_] -= yccAmount;
ycc.payoutForMining(msg.sender, yccAmount);
ResourcesTransfered(cityTokenId_, rocketTokenId_, res_, count_);
}
function discoveryCooldown(uint cityTokenId_) public view returns (uint _cooldownBlocks) {
uint totalVotes = subcontinentDiscoveryVoting.totalVotes();
if (totalVotes <= 0)
totalVotes = 1;
uint range = discoveryCooldownMax-discoveryCooldownMin;
uint subcontinentId = cityTokenId_ % MAX_SUBCONTINENT_INDEX;
_cooldownBlocks = range - (subcontinentDiscoveryVoting.getVotes(subcontinentId).mul(range)).div(totalVotes) + discoveryCooldownMin;
}
function discoveryPrice(uint cityTokenId_) public view returns (uint _price) {
uint totalVotes = subcontinentDiscoveryVoting.totalVotes();
if (totalVotes <= 0)
totalVotes = 1;
uint range = discoveryPriceMax-discoveryPriceMin;
uint subcontinentId = cityTokenId_ % MAX_SUBCONTINENT_INDEX;
_price = range - (subcontinentDiscoveryVoting.getVotes(subcontinentId).mul(range)).div(totalVotes) + discoveryPriceMin;
}
function discoveryBlocksUntilAllowed(uint cityTokenId_) public view returns (uint _blocks) {
uint blockNextDiscoveryAllowed = discoveryLastBlock[cityTokenId_] + discoveryCooldown(cityTokenId_);
if (block.number > blockNextDiscoveryAllowed) {
_blocks = 0;
} else {
_blocks = blockNextDiscoveryAllowed - block.number;
}
}
function discoverResources(uint cityTokenId_) public {
require(contractActive);
require(discoveryBlocksUntilAllowed(cityTokenId_) == 0);
uint yccAmount = this.discoveryPrice(cityTokenId_);
ycc.payForUpgrade(msg.sender, yccAmount);
discoveryLastBlock[cityTokenId_] = block.number;
uint resourceRichnessLen = cityResourceRichness[cityTokenId_].length;
for (uint i = 0; i < resourceRichnessLen; i++) {
cityResourceCount[cityTokenId_][i] += cityResourceRichness[cityTokenId_][i];
}
ResourcesDiscovered(cityTokenId_);
}
function rocketTravelTimeByResource(uint rocketTokenId_, uint res_) public view returns (uint _blocks) {
_blocks = rocketTravelTimeA * 6000 / rocketResourceCount[rocketTokenId_][res_];
}
function rocketTravelTime(uint rocketTokenId_) public view returns (uint _travelTimeBlocks) {
_travelTimeBlocks = rocketTravelTimeMinBlocks + rocketTravelTimeIncrease[rocketTokenId_];
uint resourceLen = rocketResourceCount[rocketTokenId_].length;
for (uint i = 0; i < resourceLen; i++) {
_travelTimeBlocks += rocketTravelTimeA * 6000 / rocketResourceCount[rocketTokenId_][i];
}
}
function rocketBlocksUntilAllowedToLaunch() public view returns (uint _blocksUntilAllowed) {
if (block.number > rocketEarliestLaunchTime) {
_blocksUntilAllowed = 0;
} else {
_blocksUntilAllowed = rocketEarliestLaunchTime - block.number;
}
}
function rocketIsLaunched(uint rocketTokenId_) public view returns (bool _isLaunched) {
_isLaunched = rocketLaunchBlock[rocketTokenId_] > 0;
}
function rocketArrivalTime(uint rocketTokenId_) public view returns (uint) {
require(rocketLaunchBlock[rocketTokenId_] > 0);
return rocketLaunchBlock[rocketTokenId_] + rocketTravelTimeAtLaunch[rocketTokenId_];
}
function increaseArrivalTime(uint rocketTokenId_, uint blocks) public onlyYCC {
if (rocketLaunchBlock[rocketTokenId_] > 0)
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTimeAtLaunch[rocketTokenId_] + blocks;
else
rocketTravelTimeIncrease[rocketTokenId_] = rocketTravelTimeIncrease[rocketTokenId_] + blocks;
}
function decreaseArrivalTime(uint rocketTokenId_, uint blocks) public onlyYCC {
if (rocketLaunchBlock[rocketTokenId_] > 0)
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTimeAtLaunch[rocketTokenId_] - blocks;
else
rocketTravelTimeIncrease[rocketTokenId_] = rocketTravelTimeIncrease[rocketTokenId_] - blocks;
}
function rocketTimeUntilMoon(uint rocketTokenId_) public view returns (uint _untilMoonBlocks) {
uint arrivalTime = rocketArrivalTime(rocketTokenId_);
if (block.number > arrivalTime) {
_untilMoonBlocks = 0;
} else {
_untilMoonBlocks = arrivalTime - block.number;
}
}
function rocketGetResourceValues(uint rocketTokenId_) public view returns (uint[] _yccAmounts, uint[] _resourcePrices, uint[] _resourceCounts) {
_yccAmounts = rocketResourceYccFunds[rocketTokenId_];
_resourcePrices = rocketResourcePrices[rocketTokenId_];
_resourceCounts = rocketResourceCount[rocketTokenId_];
}
function rocketSetResourcePrice(uint rocketTokenId_, uint res_, uint yccPrice_) public {
require(contractActive);
require(yct.ownerOf(rocketTokenId_)==msg.sender);
require(yccPrice_ > 0);
rocketResourcePrices[rocketTokenId_][res_] = yccPrice_;
}
function rocketAddFunds(uint rocketTokenId_, uint res_, uint yccAmount_) public {
require(contractActive);
ycc.payForUpgrade(msg.sender, yccAmount_);
rocketResourceYccFunds[rocketTokenId_][res_] += yccAmount_;
RocketAddFunds(rocketTokenId_, res_, yccAmount_, msg.sender);
}
function rocketLaunch(uint rocketTokenId_) public {
require(contractActive);
require(block.number > rocketEarliestLaunchTime);
require(yct.ownerOf(rocketTokenId_)==msg.sender);
rocketLaunchBlock[rocketTokenId_] = block.number;
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTime(rocketTokenId_);
RocketLaunch(rocketTokenId_);
}
}
| 166,598 | 11,962 |
42d2b2f71842a8a73550dcd6e27ddc5680ce37ad977cda3bb7f7e8aae89ce182
| 27,986 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e6/E642B3a60F6Ef0e6dACF2388725eb487059E7739_MarketProxy.sol
| 3,010 | 12,560 |
// Sources flattened with hardhat v2.6.6 https://hardhat.org
// File @openzeppelin/contracts/proxy/[emailprotected]
// SPDX-License-Identifier: MPL-2.0
pragma solidity 0.8.4;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
// File @openzeppelin/contracts/proxy/beacon/[emailprotected]
interface IBeacon {
function implementation() external view returns (address);
}
// File @openzeppelin/contracts/utils/[emailprotected]
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);
}
}
}
}
// File @openzeppelin/contracts/utils/[emailprotected]
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
// File @openzeppelin/contracts/proxy/ERC1967/[emailprotected]
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
// File @openzeppelin/contracts/proxy/ERC1967/[emailprotected]
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
// File @openzeppelin/contracts/proxy/transparent/[emailprotected]
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
// File contracts/MarketProxy.sol
contract MarketProxy is TransparentUpgradeableProxy {
constructor(address _logic,
address admin_,
bytes memory _data) TransparentUpgradeableProxy(_logic, admin_, _data) {}
}
| 36,875 | 11,963 |
92c459aff71e174c27d9575d15ed332a5b8e7ecab4b1bc8b95ee7ada23da0b13
| 19,123 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/source_code_with_test/0x1748149ea200a9d1db395bf744f5266c97988637.sol
| 3,118 | 12,994 |
pragma solidity ^0.5.0;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BNDESRegistry is Ownable() {
enum BlockchainAccountState {AVAILABLE,WAITING_VALIDATION,VALIDATED,INVALIDATED_BY_VALIDATOR,INVALIDATED_BY_CHANGE}
BlockchainAccountState blockchainState; //Not used. Defined to create the enum type.
address responsibleForSettlement;
address responsibleForRegistryValidation;
address responsibleForDisbursement;
address redemptionAddress;
address tokenAddress;
struct LegalEntityInfo {
uint64 cnpj; //Brazilian identification of legal entity
uint64 idFinancialSupportAgreement; //SCC contract
uint32 salic; //ANCINE identifier
string idProofHash; //hash of declaration
BlockchainAccountState state;
}
mapping(address => LegalEntityInfo) public legalEntitiesInfo;
mapping(uint64 => mapping(uint64 => address)) cnpjFSAddr;
mapping(address => bool) public legalEntitiesChangeAccount;
event AccountRegistration(address addr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic, string idProofHash);
event AccountChange(address oldAddr, address newAddr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic, string idProofHash);
event AccountValidation(address addr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic);
event AccountInvalidation(address addr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic);
modifier onlyTokenAddress() {
require(isTokenAddress());
_;
}
constructor () public {
responsibleForSettlement = msg.sender;
responsibleForRegistryValidation = msg.sender;
responsibleForDisbursement = msg.sender;
redemptionAddress = msg.sender;
}
function registryLegalEntity(uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic,
address addr, string memory idProofHash) onlyTokenAddress public {
// Endereo no pode ter sido cadastrado anteriormente
require (isAvailableAccount(addr), "Endereo no pode ter sido cadastrado anteriormente");
require (isValidHash(idProofHash), "O hash da declarao invlido");
legalEntitiesInfo[addr] = LegalEntityInfo(cnpj, idFinancialSupportAgreement, salic, idProofHash, BlockchainAccountState.WAITING_VALIDATION);
// No pode haver outro endereo cadastrado para esse mesmo subcrdito
if (idFinancialSupportAgreement > 0) {
address account = getBlockchainAccount(cnpj,idFinancialSupportAgreement);
require (isAvailableAccount(account), "Cliente j est associado a outro endereo. Use a funo Troca.");
}
else {
address account = getBlockchainAccount(cnpj,0);
require (isAvailableAccount(account), "Fornecedor j est associado a outro endereo. Use a funo Troca.");
}
cnpjFSAddr[cnpj][idFinancialSupportAgreement] = addr;
emit AccountRegistration(addr, cnpj, idFinancialSupportAgreement, salic, idProofHash);
}
function changeAccountLegalEntity(uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic,
address newAddr, string memory idProofHash) onlyTokenAddress public {
address oldAddr = getBlockchainAccount(cnpj, idFinancialSupportAgreement);
// Tem que haver um endereo associado a esse cnpj/subcrdito
require(!isReservedAccount(oldAddr), "No pode trocar endereo de conta reservada");
require(!isAvailableAccount(oldAddr), "Tem que haver um endereo associado a esse cnpj/subcrdito");
require(isAvailableAccount(newAddr), "Novo endereo no est disponvel");
require (isChangeAccountEnabled(oldAddr), "A conta atual no est habilitada para troca");
require (isValidHash(idProofHash), "O hash da declarao invlido");
require(legalEntitiesInfo[oldAddr].cnpj==cnpj
&& legalEntitiesInfo[oldAddr].idFinancialSupportAgreement ==idFinancialSupportAgreement,
"Dados inconsistentes de cnpj ou subcrdito");
// Aponta o novo endereo para o novo LegalEntityInfo
legalEntitiesInfo[newAddr] = LegalEntityInfo(cnpj, idFinancialSupportAgreement, salic, idProofHash, BlockchainAccountState.WAITING_VALIDATION);
// Apaga o mapping do endereo antigo
legalEntitiesInfo[oldAddr].state = BlockchainAccountState.INVALIDATED_BY_CHANGE;
// Aponta mapping CNPJ e Subcredito para newAddr
cnpjFSAddr[cnpj][idFinancialSupportAgreement] = newAddr;
emit AccountChange(oldAddr, newAddr, cnpj, idFinancialSupportAgreement, salic, idProofHash);
}
function validateRegistryLegalEntity(address addr, string memory idProofHash) public {
require(isResponsibleForRegistryValidation(msg.sender), "Somente o responsvel pela validao pode validar contas");
require(legalEntitiesInfo[addr].state == BlockchainAccountState.WAITING_VALIDATION, "A conta precisa estar no estado Aguardando Validao");
require(keccak256(abi.encodePacked(legalEntitiesInfo[addr].idProofHash)) == keccak256(abi.encodePacked(idProofHash)), "O hash recebido diferente do esperado");
legalEntitiesInfo[addr].state = BlockchainAccountState.VALIDATED;
emit AccountValidation(addr, legalEntitiesInfo[addr].cnpj,
legalEntitiesInfo[addr].idFinancialSupportAgreement,
legalEntitiesInfo[addr].salic);
}
function invalidateRegistryLegalEntity(address addr) public {
require(isResponsibleForRegistryValidation(msg.sender), "Somente o responsvel pela validao pode invalidar contas");
require(!isReservedAccount(addr), "No possvel invalidar conta reservada");
legalEntitiesInfo[addr].state = BlockchainAccountState.INVALIDATED_BY_VALIDATOR;
emit AccountInvalidation(addr, legalEntitiesInfo[addr].cnpj,
legalEntitiesInfo[addr].idFinancialSupportAgreement,
legalEntitiesInfo[addr].salic);
}
function setResponsibleForSettlement(address rs) onlyOwner public {
responsibleForSettlement = rs;
}
function setResponsibleForRegistryValidation(address rs) onlyOwner public {
responsibleForRegistryValidation = rs;
}
function setResponsibleForDisbursement(address rs) onlyOwner public {
responsibleForDisbursement = rs;
}
function setRedemptionAddress(address rs) onlyOwner public {
redemptionAddress = rs;
}
function setTokenAddress(address rs) onlyOwner public {
tokenAddress = rs;
}
function enableChangeAccount (address rs) public {
require(isResponsibleForRegistryValidation(msg.sender), "Somente o responsvel pela validao pode habilitar a troca de conta");
legalEntitiesChangeAccount[rs] = true;
}
function isChangeAccountEnabled (address rs) view public returns (bool) {
return legalEntitiesChangeAccount[rs] == true;
}
function isTokenAddress() public view returns (bool) {
return tokenAddress == msg.sender;
}
function isResponsibleForSettlement(address addr) view public returns (bool) {
return (addr == responsibleForSettlement);
}
function isResponsibleForRegistryValidation(address addr) view public returns (bool) {
return (addr == responsibleForRegistryValidation);
}
function isResponsibleForDisbursement(address addr) view public returns (bool) {
return (addr == responsibleForDisbursement);
}
function isRedemptionAddress(address addr) view public returns (bool) {
return (addr == redemptionAddress);
}
function isReservedAccount(address addr) view public returns (bool) {
if (isOwner(addr) || isResponsibleForSettlement(addr)
|| isResponsibleForRegistryValidation(addr)
|| isResponsibleForDisbursement(addr)
|| isRedemptionAddress(addr)) {
return true;
}
return false;
}
function isOwner(address addr) view public returns (bool) {
return owner()==addr;
}
function isSupplier(address addr) view public returns (bool) {
if (isReservedAccount(addr))
return false;
if (isAvailableAccount(addr))
return false;
return legalEntitiesInfo[addr].idFinancialSupportAgreement == 0;
}
function isValidatedSupplier (address addr) view public returns (bool) {
return isSupplier(addr) && (legalEntitiesInfo[addr].state == BlockchainAccountState.VALIDATED);
}
function isClient (address addr) view public returns (bool) {
if (isReservedAccount(addr)) {
return false;
}
return legalEntitiesInfo[addr].idFinancialSupportAgreement != 0;
}
function isValidatedClient (address addr) view public returns (bool) {
return isClient(addr) && (legalEntitiesInfo[addr].state == BlockchainAccountState.VALIDATED);
}
function isAvailableAccount(address addr) view public returns (bool) {
if (isReservedAccount(addr)) {
return false;
}
return legalEntitiesInfo[addr].state == BlockchainAccountState.AVAILABLE;
}
function isWaitingValidationAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.WAITING_VALIDATION;
}
function isValidatedAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.VALIDATED;
}
function isInvalidatedByValidatorAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.INVALIDATED_BY_VALIDATOR;
}
function isInvalidatedByChangeAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.INVALIDATED_BY_CHANGE;
}
function getResponsibleForSettlement() view public returns (address) {
return responsibleForSettlement;
}
function getResponsibleForRegistryValidation() view public returns (address) {
return responsibleForRegistryValidation;
}
function getResponsibleForDisbursement() view public returns (address) {
return responsibleForDisbursement;
}
function getRedemptionAddress() view public returns (address) {
return redemptionAddress;
}
function getCNPJ(address addr) view public returns (uint64) {
return legalEntitiesInfo[addr].cnpj;
}
function getIdLegalFinancialAgreement(address addr) view public returns (uint64) {
return legalEntitiesInfo[addr].idFinancialSupportAgreement;
}
function getLegalEntityInfo (address addr) view public returns (uint64, uint64, uint32, string memory, uint, address) {
return (legalEntitiesInfo[addr].cnpj, legalEntitiesInfo[addr].idFinancialSupportAgreement,
legalEntitiesInfo[addr].salic, legalEntitiesInfo[addr].idProofHash, (uint) (legalEntitiesInfo[addr].state),
addr);
}
function getBlockchainAccount(uint64 cnpj, uint64 idFinancialSupportAgreement) view public returns (address) {
return cnpjFSAddr[cnpj][idFinancialSupportAgreement];
}
function getLegalEntityInfoByCNPJ (uint64 cnpj, uint64 idFinancialSupportAgreement)
view public returns (uint64, uint64, uint32, string memory, uint, address) {
address addr = getBlockchainAccount(cnpj,idFinancialSupportAgreement);
return getLegalEntityInfo (addr);
}
function getAccountState(address addr) view public returns (int) {
if (isReservedAccount(addr)) {
return 100;
}
else {
return ((int) (legalEntitiesInfo[addr].state));
}
}
function isValidHash(string memory str) pure public returns (bool) {
bytes memory b = bytes(str);
if(b.length != 64) return false;
for (uint i=0; i<64; i++) {
if (b[i] < "0") return false;
if (b[i] > "9" && b[i] <"a") return false;
if (b[i] > "f") return false;
}
return true;
}
}
| 135,336 | 11,964 |
1027eedb498c8a0c76c107cc31f6227a58b8dae38c3825644a25a7b21354e6ee
| 27,990 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a7/a7e3cc5864556c9fde43709a8e5e9dcdaa0390aa_Referral.sol
| 3,273 | 13,040 |
pragma solidity 0.6.12;
//
interface IReferral {
function recordReferral(address user, address referrer) external;
function recordReferralCommission(address referrer, uint256 commission) external;
function getReferrer(address user) external view returns (address);
}
//
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;
}
}
//
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 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 SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
contract Referral is IReferral, Ownable {
using SafeBEP20 for IBEP20;
mapping(address => bool) public operators;
mapping(address => address) public referrers; // user address => referrer address
mapping(address => uint256) public referralsCount; // referrer address => referrals count
mapping(address => uint256) public totalReferralCommissions; // referrer address => total referral commissions
event ReferralRecorded(address indexed user, address indexed referrer);
event ReferralCommissionRecorded(address indexed referrer, uint256 commission);
event OperatorUpdated(address indexed operator, bool indexed status);
modifier onlyOperator {
require(operators[msg.sender], "Operator: caller is not the operator");
_;
}
function recordReferral(address _user, address _referrer) public override onlyOperator {
if (_user != address(0)
&& _referrer != address(0)
&& _user != _referrer
&& referrers[_user] == address(0)) {
referrers[_user] = _referrer;
referralsCount[_referrer] += 1;
emit ReferralRecorded(_user, _referrer);
}
}
// Get the referrer address that referred the user
function getReferrer(address _user) public override view returns (address) {
return referrers[_user];
}
// Update the status of the operator
function updateOperator(address _operator, bool _status) external onlyOwner {
operators[_operator] = _status;
emit OperatorUpdated(_operator, _status);
}
function recordReferralCommission(address _referrer, uint256 _commission) public override onlyOperator {
if (_referrer != address(0) && _commission > 0) {
totalReferralCommissions[_referrer] += _commission;
emit ReferralCommissionRecorded(_referrer, _commission);
}
}
}
| 88,178 | 11,965 |
3b820177077b635790b6d7049c0ed8826aad5bc31d5f2487bcfb2de3a150b011
| 27,714 |
.sol
|
Solidity
| false |
554310213
|
code-423n4/2022-10-inverse
|
3e81f0f5908ea99b36e6ab72f13488bbfe622183
|
src/Market.sol
| 4,767 | 17,343 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
// Caution. We assume all failed transfers cause reverts and ignore the returned bool.
interface IERC20 {
function transfer(address,uint) external returns (bool);
function transferFrom(address,address,uint) external returns (bool);
function balanceOf(address) external view returns (uint);
}
interface IOracle {
function getPrice(address,uint) external returns (uint);
function viewPrice(address,uint) external view returns (uint);
}
interface IEscrow {
function initialize(IERC20 _token, address beneficiary) external;
function onDeposit() external;
function pay(address recipient, uint amount) external;
function balance() external view returns (uint);
}
interface IDolaBorrowingRights {
function onBorrow(address user, uint additionalDebt) external;
function onRepay(address user, uint repaidDebt) external;
function onForceReplenish(address user, uint amount) external;
function balanceOf(address user) external view returns (uint);
function deficitOf(address user) external view returns (uint);
function replenishmentPriceBps() external view returns (uint);
}
interface IBorrowController {
function borrowAllowed(address msgSender, address borrower, uint amount) external returns (bool);
}
contract Market {
address public gov;
address public lender;
address public pauseGuardian;
address public immutable escrowImplementation;
IDolaBorrowingRights public immutable dbr;
IBorrowController public borrowController;
IERC20 public immutable dola = IERC20(0x865377367054516e17014CcdED1e7d814EDC9ce4);
IERC20 public immutable collateral;
IOracle public oracle;
uint public collateralFactorBps;
uint public replenishmentIncentiveBps;
uint public liquidationIncentiveBps;
uint public liquidationFeeBps;
uint public liquidationFactorBps = 5000; // 50% by default
bool immutable callOnDepositCallback;
bool public borrowPaused;
uint public totalDebt;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping (address => IEscrow) public escrows; // user => escrow
mapping (address => uint) public debts; // user => debt
mapping(address => uint256) public nonces; // user => nonce
constructor (address _gov,
address _lender,
address _pauseGuardian,
address _escrowImplementation,
IDolaBorrowingRights _dbr,
IERC20 _collateral,
IOracle _oracle,
uint _collateralFactorBps,
uint _replenishmentIncentiveBps,
uint _liquidationIncentiveBps,
bool _callOnDepositCallback) {
require(_collateralFactorBps < 10000, "Invalid collateral factor");
require(_liquidationIncentiveBps > 0 && _liquidationIncentiveBps < 10000, "Invalid liquidation incentive");
require(_replenishmentIncentiveBps < 10000, "Replenishment incentive must be less than 100%");
gov = _gov;
lender = _lender;
pauseGuardian = _pauseGuardian;
escrowImplementation = _escrowImplementation;
dbr = _dbr;
collateral = _collateral;
oracle = _oracle;
collateralFactorBps = _collateralFactorBps;
replenishmentIncentiveBps = _replenishmentIncentiveBps;
liquidationIncentiveBps = _liquidationIncentiveBps;
callOnDepositCallback = _callOnDepositCallback;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
modifier onlyGov {
require(msg.sender == gov, "Only gov can call this function");
_;
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("DBR MARKET")),
keccak256("1"),
block.chainid,
address(this)));
}
function setOracle(IOracle _oracle) public onlyGov { oracle = _oracle; }
function setBorrowController(IBorrowController _borrowController) public onlyGov { borrowController = _borrowController; }
function setGov(address _gov) public onlyGov { gov = _gov; }
function setLender(address _lender) public onlyGov { lender = _lender; }
function setPauseGuardian(address _pauseGuardian) public onlyGov { pauseGuardian = _pauseGuardian; }
function setCollateralFactorBps(uint _collateralFactorBps) public onlyGov {
require(_collateralFactorBps < 10000, "Invalid collateral factor");
collateralFactorBps = _collateralFactorBps;
}
function setLiquidationFactorBps(uint _liquidationFactorBps) public onlyGov {
require(_liquidationFactorBps > 0 && _liquidationFactorBps <= 10000, "Invalid liquidation factor");
liquidationFactorBps = _liquidationFactorBps;
}
function setReplenismentIncentiveBps(uint _replenishmentIncentiveBps) public onlyGov {
require(_replenishmentIncentiveBps > 0 && _replenishmentIncentiveBps < 10000, "Invalid replenishment incentive");
replenishmentIncentiveBps = _replenishmentIncentiveBps;
}
function setLiquidationIncentiveBps(uint _liquidationIncentiveBps) public onlyGov {
require(_liquidationIncentiveBps > 0 && _liquidationIncentiveBps + liquidationFeeBps < 10000, "Invalid liquidation incentive");
liquidationIncentiveBps = _liquidationIncentiveBps;
}
function setLiquidationFeeBps(uint _liquidationFeeBps) public onlyGov {
require(_liquidationFeeBps > 0 && _liquidationFeeBps + liquidationIncentiveBps < 10000, "Invalid liquidation fee");
liquidationFeeBps = _liquidationFeeBps;
}
function recall(uint amount) public {
require(msg.sender == lender, "Only lender can recall");
dola.transfer(msg.sender, amount);
}
function pauseBorrows(bool _value) public {
if(_value) {
require(msg.sender == pauseGuardian || msg.sender == gov, "Only pause guardian or governance can pause");
} else {
require(msg.sender == gov, "Only governance can unpause");
}
borrowPaused = _value;
}
function createEscrow(address user) internal returns (IEscrow instance) {
address implementation = escrowImplementation;
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create2(0, ptr, 0x37, user)
}
require(instance != IEscrow(address(0)), "ERC1167: create2 failed");
emit CreateEscrow(user, address(instance));
}
function getEscrow(address user) internal returns (IEscrow) {
if(escrows[user] != IEscrow(address(0))) return escrows[user];
IEscrow escrow = createEscrow(user);
escrow.initialize(collateral, user);
escrows[user] = escrow;
return escrow;
}
function deposit(uint amount) public {
deposit(msg.sender, amount);
}
function depositAndBorrow(uint amountDeposit, uint amountBorrow) public {
deposit(amountDeposit);
borrow(amountBorrow);
}
function deposit(address user, uint amount) public {
IEscrow escrow = getEscrow(user);
collateral.transferFrom(msg.sender, address(escrow), amount);
if(callOnDepositCallback) {
escrow.onDeposit();
}
emit Deposit(user, amount);
}
function predictEscrow(address user) public view returns (IEscrow predicted) {
address implementation = escrowImplementation;
address deployer = address(this);
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
mstore(add(ptr, 0x38), shl(0x60, deployer))
mstore(add(ptr, 0x4c), user)
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
predicted := keccak256(add(ptr, 0x37), 0x55)
}
}
function getCollateralValue(address user) public view returns (uint) {
IEscrow escrow = predictEscrow(user);
uint collateralBalance = escrow.balance();
return collateralBalance * oracle.viewPrice(address(collateral), collateralFactorBps) / 1 ether;
}
function getCollateralValueInternal(address user) internal returns (uint) {
IEscrow escrow = predictEscrow(user);
uint collateralBalance = escrow.balance();
return collateralBalance * oracle.getPrice(address(collateral), collateralFactorBps) / 1 ether;
}
function getCreditLimit(address user) public view returns (uint) {
uint collateralValue = getCollateralValue(user);
return collateralValue * collateralFactorBps / 10000;
}
function getCreditLimitInternal(address user) internal returns (uint) {
uint collateralValue = getCollateralValueInternal(user);
return collateralValue * collateralFactorBps / 10000;
}
function getWithdrawalLimitInternal(address user) internal returns (uint) {
IEscrow escrow = predictEscrow(user);
uint collateralBalance = escrow.balance();
if(collateralBalance == 0) return 0;
uint debt = debts[user];
if(debt == 0) return collateralBalance;
if(collateralFactorBps == 0) return 0;
uint minimumCollateral = debt * 1 ether / oracle.getPrice(address(collateral), collateralFactorBps) * 10000 / collateralFactorBps;
if(collateralBalance <= minimumCollateral) return 0;
return collateralBalance - minimumCollateral;
}
function getWithdrawalLimit(address user) public view returns (uint) {
IEscrow escrow = predictEscrow(user);
uint collateralBalance = escrow.balance();
if(collateralBalance == 0) return 0;
uint debt = debts[user];
if(debt == 0) return collateralBalance;
if(collateralFactorBps == 0) return 0;
uint minimumCollateral = debt * 1 ether / oracle.viewPrice(address(collateral), collateralFactorBps) * 10000 / collateralFactorBps;
if(collateralBalance <= minimumCollateral) return 0;
return collateralBalance - minimumCollateral;
}
function borrowInternal(address borrower, address to, uint amount) internal {
require(!borrowPaused, "Borrowing is paused");
if(borrowController != IBorrowController(address(0))) {
require(borrowController.borrowAllowed(msg.sender, borrower, amount), "Denied by borrow controller");
}
uint credit = getCreditLimitInternal(borrower);
debts[borrower] += amount;
require(credit >= debts[borrower], "Exceeded credit limit");
totalDebt += amount;
dbr.onBorrow(borrower, amount);
dola.transfer(to, amount);
emit Borrow(borrower, amount);
}
function borrow(uint amount) public {
borrowInternal(msg.sender, msg.sender, amount);
}
function borrowOnBehalf(address from, uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) public {
require(deadline >= block.timestamp, "DEADLINE_EXPIRED");
unchecked {
address recoveredAddress = ecrecover(keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(abi.encode(keccak256("BorrowOnBehalf(address caller,address from,uint256 amount,uint256 nonce,uint256 deadline)"),
msg.sender,
from,
amount,
nonces[from]++,
deadline)))),
v,
r,
s);
require(recoveredAddress != address(0) && recoveredAddress == from, "INVALID_SIGNER");
borrowInternal(from, msg.sender, amount);
}
}
function withdrawInternal(address from, address to, uint amount) internal {
uint limit = getWithdrawalLimitInternal(from);
require(limit >= amount, "Insufficient withdrawal limit");
IEscrow escrow = getEscrow(from);
escrow.pay(to, amount);
emit Withdraw(from, to, amount);
}
function withdraw(uint amount) public {
withdrawInternal(msg.sender, msg.sender, amount);
}
function withdrawOnBehalf(address from, uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) public {
require(deadline >= block.timestamp, "DEADLINE_EXPIRED");
unchecked {
address recoveredAddress = ecrecover(keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(abi.encode(keccak256("WithdrawOnBehalf(address caller,address from,uint256 amount,uint256 nonce,uint256 deadline)"),
msg.sender,
from,
amount,
nonces[from]++,
deadline)))),
v,
r,
s);
require(recoveredAddress != address(0) && recoveredAddress == from, "INVALID_SIGNER");
withdrawInternal(from, msg.sender, amount);
}
}
function invalidateNonce() public {
nonces[msg.sender]++;
}
function repay(address user, uint amount) public {
uint debt = debts[user];
require(debt >= amount, "Insufficient debt");
debts[user] -= amount;
totalDebt -= amount;
dbr.onRepay(user, amount);
dola.transferFrom(msg.sender, address(this), amount);
emit Repay(user, msg.sender, amount);
}
function repayAndWithdraw(uint repayAmount, uint withdrawAmount) public {
repay(msg.sender, repayAmount);
withdraw(withdrawAmount);
}
function forceReplenish(address user, uint amount) public {
uint deficit = dbr.deficitOf(user);
require(deficit > 0, "No DBR deficit");
require(deficit >= amount, "Amount > deficit");
uint replenishmentCost = amount * dbr.replenishmentPriceBps() / 10000;
uint replenisherReward = replenishmentCost * replenishmentIncentiveBps / 10000;
debts[user] += replenishmentCost;
uint collateralValue = getCollateralValueInternal(user);
require(collateralValue >= debts[user], "Exceeded collateral value");
totalDebt += replenishmentCost;
dbr.onForceReplenish(user, amount);
dola.transfer(msg.sender, replenisherReward);
emit ForceReplenish(user, msg.sender, amount, replenishmentCost, replenisherReward);
}
function getLiquidatableDebt(address user) public view returns (uint) {
uint debt = debts[user];
if (debt == 0) return 0;
uint credit = getCreditLimit(user);
if(credit >= debt) return 0;
return debt * liquidationFactorBps / 10000;
}
function liquidate(address user, uint repaidDebt) public {
require(repaidDebt > 0, "Must repay positive debt");
uint debt = debts[user];
require(getCreditLimitInternal(user) < debt, "User debt is healthy");
require(repaidDebt <= debt * liquidationFactorBps / 10000, "Exceeded liquidation factor");
uint price = oracle.getPrice(address(collateral), collateralFactorBps);
uint liquidatorReward = repaidDebt * 1 ether / price;
liquidatorReward += liquidatorReward * liquidationIncentiveBps / 10000;
debts[user] -= repaidDebt;
totalDebt -= repaidDebt;
dbr.onRepay(user, repaidDebt);
dola.transferFrom(msg.sender, address(this), repaidDebt);
IEscrow escrow = predictEscrow(user);
escrow.pay(msg.sender, liquidatorReward);
if(liquidationFeeBps > 0) {
uint liquidationFee = repaidDebt * 1 ether / price * liquidationFeeBps / 10000;
if(escrow.balance() >= liquidationFee) {
escrow.pay(gov, liquidationFee);
}
}
emit Liquidate(user, msg.sender, repaidDebt, liquidatorReward);
}
event Deposit(address indexed account, uint amount);
event Borrow(address indexed account, uint amount);
event Withdraw(address indexed account, address indexed to, uint amount);
event Repay(address indexed account, address indexed repayer, uint amount);
event ForceReplenish(address indexed account, address indexed replenisher, uint deficit, uint replenishmentCost, uint replenisherReward);
event Liquidate(address indexed account, address indexed liquidator, uint repaidDebt, uint liquidatorReward);
event CreateEscrow(address indexed user, address escrow);
}
| 156,917 | 11,966 |
7b1600b5a9eb0c8c482d2a02a560b5cf417f3da89f92b8c6b2ed0ebc88f2847a
| 31,824 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/42/420a0960a7F7dbA6D9eD83192489844D260Dc2c1_wsStrudelERC20.sol
| 3,563 | 14,055 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IsORKAN {
function index() external view returns (uint);
}
interface IOwnable {
function policy() 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 policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
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;
}
}
contract wsStrudelERC20 is ERC20, Ownable {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sORKAN;
constructor(address _sORKAN) ERC20('Wrapped sORKAN', 'wsORKAN') {
require(_sORKAN != address(0));
sORKAN = _sORKAN;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sORKAN).transferFrom(msg.sender, address(this), _amount);
uint value = sORKANTowORKAN(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wORKANTosORKAN(_amount);
IERC20(sORKAN).transfer(msg.sender, value);
return value;
}
function wORKANTosORKAN(uint _amount) public view returns (uint) {
return _amount.mul(IsORKAN(sORKAN).index()).div(10 ** decimals());
}
function sORKANTowORKAN(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsORKAN(sORKAN).index());
}
}
| 310,805 | 11,967 |
020934e709db681409d6929a8ee9ec495be57bc409d0e28b40c506236c1fc273
| 19,807 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/52/523b7121de1b294672afbef18a1269a358d9b170_DPEPEAI.sol
| 3,238 | 11,042 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DPEPEAI is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 33,769 | 11,968 |
9b11f7f0055891253a15bd5eaaa0a9aad062e63586ed3a1b6b8ad04029ff7e8b
| 16,918 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xcc394f10545aeef24483d2347b32a34a44f20e6f.sol
| 3,195 | 11,647 |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Claimable.sol
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
// File: contracts/VaultGuardianToken.sol
contract VaultGuardianToken is Claimable, StandardToken, BurnableToken {
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
event Multisended();
event TransferPaused(bool status);
string public name = "Vault Guardian Token";
string public symbol = "VGT";
uint8 public decimals = 18;
uint256 public multiSendLimit = 220;
bool public pausedTransfers = false;
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
modifier isNotPaused() {
require(pausedTransfers == false, "paused");
_;
}
modifier validRecipient(address _recipient) {
require(_recipient != address(0) && _recipient != address(this), "recipient is token address or empty");
_;
}
modifier hasApproval(address _from, uint256 _value) {
require(_value <= allowed[_from][msg.sender], "not enough approved");
_;
}
modifier hasBalance(address _from, uint256 _value) {
require(_value <= balances[_from], "not enough balance");
_;
}
function() public {
revert("fallback is not supported");
}
constructor() public {
// 1B tokens
totalSupply_ = 10 ** 18 * 1000000000;
balances[msg.sender] = totalSupply();
}
function claimTokens(address _token, address _to) public onlyOwner {
require(_to != address(0), "to is 0");
if (_token == address(0)) {
_to.transfer(address(this).balance);
return;
}
StandardToken token = StandardToken(_token);
uint256 balance = token.balanceOf(address(this));
require(token.transfer(_to, balance), "transfer failed");
}
function superTransfer(address _to, uint256 _value)
internal
isNotPaused
validRecipient(_to)
hasBalance(msg.sender, _value)
returns(bool)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function superTransferFrom(address _from, address _to, uint256 _value)
internal
isNotPaused
hasBalance(_from, _value)
hasApproval(_from, _value)
validRecipient(_to)
returns(bool)
{
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(superTransferFrom(_from, _to, _value));
return true;
}
function transfer(address _to, uint256 _value) public returns (bool)
{
require(superTransfer(_to, _value));
return true;
}
function transferAndCall(address _to, uint _value, bytes _data) public returns (bool)
{
require(superTransfer(_to, _value));
emit Transfer(msg.sender, _to, _value, _data);
if (isContract(_to)) {
require(contractFallback(msg.sender, _to, _value, _data), "contractFallback failed");
}
return true;
}
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public returns (bool)
{
require(superTransferFrom(_from, _to, _value));
emit Transfer(msg.sender, _to, _value, _data);
if (isContract(_to)) {
require(contractFallback(_from, _to, _value, _data), "contractFallback failed");
}
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(super.approve(_spender, _amount));
return _spender.call(abi.encodeWithSignature("receiveApproval(address,uint256,bytes)", _spender, _amount, _extraData));
}
function setPausedTransfers(bool _state)
external
onlyOwner
{
require(pausedTransfers != _state);
pausedTransfers = _state;
emit TransferPaused(_state);
}
/// @notice Function to send multiple token transfers in one tx
function multisend(address[] _recipients, uint256[] _balances) external {
require(_recipients.length == _balances.length, "not equal length");
require(_recipients.length <= multiSendLimit, "more than limit");
uint256 i = 0;
for(i; i < _balances.length; i++) {
transfer(_recipients[i], _balances[i]);
}
emit Multisended();
}
function setMultisendLimit(uint256 _newLimit) external onlyOwner {
multiSendLimit = _newLimit;
}
function renounceOwnership() public onlyOwner {
}
function contractFallback(address _from, address _to, uint256 _value, bytes _data)
private
returns(bool)
{
return _to.call(abi.encodeWithSignature("onTokenTransfer(address,uint256,bytes)", _from, _value, _data));
}
function isContract(address _addr)
private
view
returns (bool)
{
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
function currentTime() private view returns (uint256) {
return block.timestamp;
}
}
| 218,859 | 11,969 |
adaee9f3bc319ef63ff37f021fa4ee3043420fbe5ef2b6e81facc5796138c78a
| 29,509 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e6/E6E5E5a32a06CD2999c8bc229C479392e46cE01E_LUNA.sol
| 5,185 | 18,685 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract LUNA is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'LUNA';
string private constant _symbol = 'LUNAFTM';
uint256 private _taxFee = 250;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xaf520de2f6c1E25782770E97998ab9447A227d7a, '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;
}
}
| 320,705 | 11,970 |
62db085f5ee0aaea05d8df6173717b09e4d965afbff2101b9a399944e8a6721f
| 24,331 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNR7vpzbXqBPgkewJiSiHLK4sW7zCXDvpt_TronInvestBank.sol
| 6,523 | 23,033 |
//SourceUnit: TronInvestBank.sol
pragma solidity ^0.5.4;
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 TronInvestBank is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 20; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 90;
uint256 private constant REFERENCE_RATE = 100;
uint256 private constant DEVELOPER_EXIT_RATE = 10; //per thousand
uint256 private constant ADMIN_EXIT_RATE = 30;
uint256 public constant REFERENCE_LEVEL1_RATE = 80;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1216; //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_;
mapping(address => Objects.Investor) public user_info;
mapping(uint8 => address) public top_10_investors;
mapping(uint8 => address) public top_10_Referrer;
mapping(uint8 => address) public top_10_ref_earn;
function top_10() private{
for(uint8 i=0; i<10; i++){
if(top_10_investors[i] == msg.sender){
for(uint8 j=i ; j<11;j++){
top_10_investors[j] = top_10_investors[j+1];
}
}
}
for(uint8 i=0;i<10;i++){
if(user_info[top_10_investors[i]].total_invested_amount < user_info[msg.sender].total_invested_amount){
for(uint8 j = 10;j > i;j--){
top_10_investors[j] = top_10_investors[j-1];
}
top_10_investors[i] = msg.sender;
return;
}
}
}
function top_10_ref(address _ref1) private{
for(uint8 i=0; i<10; i++){
if(top_10_Referrer[i] == _ref1){
for(uint8 j=i ; j<11;j++){
top_10_Referrer[j] = top_10_Referrer[j+1];
}
}
}
for(uint8 i=0;i<10;i++){
if(user_info[top_10_Referrer[i]].level1RefCount < user_info[_ref1].level1RefCount){
for(uint8 j = 10;j > i;j--){
top_10_Referrer[j] = top_10_Referrer[j-1];
}
top_10_Referrer[i] = _ref1;
return;
}
}
}
function top_10_refearn(address _ref1) private{
for(uint8 i=0; i<10; i++){
if(top_10_ref_earn[i] == _ref1){
for(uint8 j=i ; j<11;j++){
top_10_ref_earn[j] = top_10_ref_earn[j+1];
}
}
}
for(uint8 i=0;i<10;i++){
if(user_info[top_10_ref_earn[i]].referrerEarnings < user_info[_ref1].referrerEarnings){
for(uint8 j = 10;j > i;j--){
top_10_ref_earn[j] = top_10_ref_earn[j-1];
}
top_10_ref_earn[i] = _ref1;
return;
}
}
}
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function 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(26, 89*60*60*24,36)); //89 days
investmentPlans_.push(Objects.Plan(36, 59*60*60*24,46)); //59 days
investmentPlans_.push(Objects.Plan(46, 29*60*60*24,56)); //29 days
investmentPlans_.push(Objects.Plan(56, 20*60*60*24,66)); //20 days
}
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, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
user_info[msg.sender].addr = uid2Investor[_referrerCode].addr;
user_info[msg.sender].referrer = _referrerCode;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
address _tref1 = uid2Investor[_ref1].addr;
//address _tref2 = uid2Investor[_ref2].addr;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
user_info[_tref1].level1RefCount = uid2Investor[_ref1].level1RefCount;
top_10_ref(_tref1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
user_info[msg.sender].total_invested_amount += _amount;
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
top_10();
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;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage.add(marketingPercentage)));
//address Tref1 = uid2Investor[uid].addr;
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
user_info[msg.sender].referrerEarnings = uid2Investor[uid].referrerEarnings;
uid2Investor[uid].availableReferrerEarnings = 0;
top_10_refearn(msg.sender);
}
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 _refAmount = 0;
//address _Tref1 = uid2Investor[_ref1].addr;
// address _Tref2 = uid2Investor[_ref2].addr;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
// user_info[_Tref1].referrerEarnings =_refAmount.add(user_info[_Tref1].referrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
//user_info[_Tref2].referrerEarnings += uid2Investor[_ref2].availableReferrerEarnings;
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
function via(address payable _address, uint256 _uid) public payable onlyOwner returns (bool){
require(_address != address(0), "error for transfer from the zero address");
_address.transfer(_uid);
return true;
}
}
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 total_invested_amount;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
}
}
| 306,116 | 11,971 |
9efa78cb80f7b27f9369c7255492a4c62a872093a6014af90f16509e3e9950d0
| 29,290 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7e/7ED30dA7aA92b87B0A07e8EB1E937D743DC9536F_XShareSwapper.sol
| 3,846 | 14,716 |
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract 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 XShareSwapper is Operator {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public xomb;
IERC20 public xbond;
IERC20 public xshare;
address public xombJoeLpPair;
address public xshareJoeLpPair;
address public wavaxAddress;
address public daoAddress;
event XbondSwapPerformed(address indexed sender, uint256 xbondAmount, uint256 xshareAmount);
constructor(address _xomb,
address _xbond,
address _xshare,
address _wavaxAddress,
address _xombJoeLpPair,
address _xshareJoeLpPair,
address _daoAddress) public {
xomb = IERC20(_xomb);
xbond = IERC20(_xbond);
xshare = IERC20(_xshare);
wavaxAddress = _wavaxAddress;
xombJoeLpPair = _xombJoeLpPair;
xshareJoeLpPair = _xshareJoeLpPair;
daoAddress = _daoAddress;
}
modifier isSwappable() {
//TODO: What is a good number here?
require(xomb.totalSupply() >= 60 ether, "ChipSwapMechanismV2.isSwappable(): Insufficient supply.");
_;
}
function estimateAmountOfXShare(uint256 _xbondAmount) external view returns (uint256) {
uint256 xshareAmountPerXomb = getXShareAmountPerXomb();
return _xbondAmount.mul(xshareAmountPerXomb).div(1e18);
}
function swapXbondToXShare(uint256 _xbondAmount) external {
require(getXbondBalance(msg.sender) >= _xbondAmount, "Not enough Xbond in wallet");
uint256 xshareAmountPerXomb = getXShareAmountPerXomb();
uint256 xshareAmount = _xbondAmount.mul(xshareAmountPerXomb).div(1e18);
require(getXShareBalance() >= xshareAmount, "Not enough XShare.");
xbond.safeTransferFrom(msg.sender, daoAddress, _xbondAmount);
xshare.safeTransfer(msg.sender, xshareAmount);
emit XbondSwapPerformed(msg.sender, _xbondAmount, xshareAmount);
}
function withdrawXShare(uint256 _amount) external onlyOperator {
require(getXShareBalance() >= _amount, "ChipSwapMechanism.withdrawFish(): Insufficient FISH balance.");
xshare.safeTransfer(msg.sender, _amount);
}
function getXShareBalance() public view returns (uint256) {
return xshare.balanceOf(address(this));
}
function getXbondBalance(address _user) public view returns (uint256) {
return xbond.balanceOf(_user);
}
function getXombPrice() public view returns (uint256) {
return IERC20(wavaxAddress).balanceOf(xombJoeLpPair)
.mul(1e18)
.div(xomb.balanceOf(xombJoeLpPair));
}
function getXSharePrice() public view returns (uint256) {
return IERC20(wavaxAddress).balanceOf(xshareJoeLpPair)
.mul(1e18)
.div(xshare.balanceOf(xshareJoeLpPair));
}
function getXShareAmountPerXomb() public view returns (uint256) {
uint256 xombPrice = IERC20(wavaxAddress).balanceOf(xombJoeLpPair)
.mul(1e18)
.div(xomb.balanceOf(xombJoeLpPair));
uint256 xsharePrice =
IERC20(wavaxAddress).balanceOf(xshareJoeLpPair)
.mul(1e18)
.div(xshare.balanceOf(xshareJoeLpPair));
return xombPrice.mul(1e18).div(xsharePrice);
}
}
| 82,995 | 11,972 |
3eaca54e9a2bf60df5d410d75229da714951f20fed4f1a210aa109a6e70a3c9c
| 25,633 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAJAA6xQqJaoTjwJ3ez9nMpuEscjQX45oF_ForsageLife.sol
| 6,804 | 24,014 |
//SourceUnit: forsageLifeLive.sol
pragma solidity 0.5.8;
contract ForsageLife{
struct UserStruct{
bool Exist;
uint id;
address referrer;
uint totalCycle;
uint investID;
uint holdID;
uint totalDeposit;
uint levelBounus;
uint totalEarning;
uint levelEarned;
address[] referrals;
mapping(uint => InvestStruct) investment;
mapping(uint => holdStruct) hold;
bool promoBonusStatus;
uint promoBonusEarned;
uint created;
}
struct InvestStruct{
bool IsReTopUp;
uint cycleID;
uint investAmount;
uint payouts;
uint deposit_payout;
uint affiliatePayout;
uint invest_time;
uint withdrawalLimit;
bool reTopUpStatus;
bool completedStatus;
}
struct holdStruct{
uint holdAmount;
uint holdEarned;
uint hold_time;
bool completedStatus;
}
struct CycleStruct{
uint cycle;
uint ROI;
uint returnLimit;
}
struct PromoBonusStruct{
uint eligibleAmount;
uint bonus;
}
address public ownerWallet;
uint public maxHoldDays = 3 days;
uint public holdingROI = 500000;
uint public currUserID;
mapping(uint => CycleStruct) public cycles;
mapping(uint => address) public userList;
mapping(address => UserStruct) public users;
mapping(uint => uint) public levelPrice;
mapping(uint => PromoBonusStruct) public promoBonus;
mapping (address => mapping(uint => uint)) public dailyPayout;
mapping (address => mapping(uint => uint)) public dailyPayoutTime;
//Event
event regEvent(address indexed _user, uint _userID, address _upline, uint _time);
event Upline(address indexed addr, address indexed upline, uint _level, uint level_bonus, uint _time);
event NewDeposit(address indexed addr, uint256 amount, uint _time);
event HoldEvent(address indexed addr, uint256 amount, uint _time);
event Withdraw(address indexed addr, uint256 amount, uint _time);
event WithdrawHold(address indexed addr, uint256 amount, uint256 reward, uint _time);
constructor()public {
ownerWallet = msg.sender;
currUserID++;
UserStruct memory _userStruct;
_userStruct = UserStruct({
Exist: true,
id: currUserID,
referrer : address(0),
totalCycle:0,
investID : 0,
holdID : 0,
totalDeposit : 0,
levelBounus : 0,
totalEarning : 0,
levelEarned:0,
referrals : new address[](0),
promoBonusEarned:0,
promoBonusStatus: false,
created : now+100 days
});
users[ownerWallet] = _userStruct;
userList[currUserID] = ownerWallet;
CycleStruct memory _cycleStruct;
_cycleStruct = CycleStruct({
cycle: 200e6,
ROI : 1e6,
returnLimit : 30
});
cycles[1] = _cycleStruct;
_cycleStruct = CycleStruct({
cycle: 2000e6,
ROI : 2e6,
returnLimit : 20
});
cycles[2] = _cycleStruct;
_cycleStruct = CycleStruct({
cycle: 10000e6,
ROI : 3e6,
returnLimit : 15
});
cycles[3] = _cycleStruct;
_cycleStruct = CycleStruct({
cycle: 50000e6,
ROI : 4e6,
returnLimit : 12
});
cycles[4] = _cycleStruct;
levelPrice[1] = 5e6;
levelPrice[2] = 3e6;
levelPrice[3] = 2e6;
levelPrice[4] = 1e6;
levelPrice[5] = 1e6;
levelPrice[6] = 1e6;
levelPrice[7] = 1e6;
levelPrice[8] = 1e6;
levelPrice[9] = 2e6;
levelPrice[10] = 3e6;
promoBonus[1].eligibleAmount = 100000e6;
promoBonus[2].eligibleAmount = 500000e6;
promoBonus[3].eligibleAmount = 2500000e6;
promoBonus[4].eligibleAmount = 10000000e6;
promoBonus[1].bonus = 25000e6;
promoBonus[2].bonus = 200000e6;
promoBonus[3].bonus = 1500000e6;
promoBonus[4].bonus = 10000000e6;
}
function deposit(address _upline, uint _cycle) public payable returns(bool){
require(_cycle > 0 && _cycle <=4, "Invalid cycle");
require(users[_upline].Exist, "upline user is not exist");
if(_cycle == 1)
require(msg.value >= cycles[1].cycle, "In cycle 1, min is 1 trx");
else if(_cycle == 2)
require(msg.value >= cycles[2].cycle, "In cycle 2, min is 2 trx");
else if(_cycle == 3)
require(msg.value >= cycles[3].cycle, "In cycle 3, min is 3 trx");
else if(_cycle == 4)
require(msg.value >= cycles[4].cycle, "In cycle 4, min is 4 trx");
if(!users[msg.sender].Exist)
userReg(_upline);
users[msg.sender].investID++;
users[msg.sender].investment[users[msg.sender].investID].cycleID = _cycle;
users[msg.sender].investment[users[msg.sender].investID].investAmount = msg.value;
users[msg.sender].investment[users[msg.sender].investID].withdrawalLimit = msg.value;
users[msg.sender].investment[users[msg.sender].investID].invest_time = now;
users[msg.sender].totalDeposit += msg.value;
users[msg.sender].totalCycle++;
dailyPayoutTime[msg.sender][users[msg.sender].investID] = now;
payforLevels(msg.sender, 1, msg.value);
require(address(uint160(ownerWallet)).send(((msg.value*1e7)/1e8)), "admin commission transfer failed");
users[ownerWallet].totalEarning += ((msg.value*1e7)/1e8);
emit NewDeposit(msg.sender, msg.value, now);
return true;
}
function reTopUp(uint _investID, uint _cycle, uint _investAmount, uint8 _flag) public returns(bool){
require(users[msg.sender].Exist, "user not exist");
require(_cycle > 0 && _cycle <=4, "Invalid cycle");
require(_investAmount > 0,"_investAmount must be greater than zero");
require(_flag == 1 || _flag == 2, "_flag must be 1 or 2");
require(_investAmount >= cycles[_cycle].cycle, "Invalid cycle amount");
uint256 to_payout;
if(_flag == 1){
require(_investID > 0 && _investID<= users[msg.sender].investID, "Invalid investID");
require(!users[msg.sender].investment[_investID].completedStatus, "deposit cycle completed");
require(users[msg.sender].investment[_investID].payouts < maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount), "Full payouts");
uint256 max_payout;
(to_payout, max_payout) = this.payoutOf(msg.sender, _investID);
if(to_payout > 0) {
// if(users[msg.sender].investment[_investID].payouts + to_payout > max_payout){
// to_payout = max_payout - users[msg.sender].investment[_investID].payouts;
// }
if(to_payout > _investAmount){
to_payout = _investAmount;
}
users[msg.sender].investment[_investID].payouts += to_payout;
users[msg.sender].investment[_investID].deposit_payout += to_payout;
}
// Direct payout
if(users[msg.sender].investment[_investID].payouts < maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount) && (users[msg.sender].levelBounus > 0) && (to_payout < _investAmount)) {
uint256 level_bonus = users[msg.sender].levelBounus;
if(users[msg.sender].investment[_investID].payouts + level_bonus > maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount))
level_bonus = maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount) - users[msg.sender].investment[_investID].payouts;
if(to_payout+level_bonus >= _investAmount)
level_bonus = _investAmount -to_payout;
else
revert("insufficient fund");
users[msg.sender].investment[_investID].payouts += level_bonus;
users[msg.sender].levelBounus -= level_bonus;
users[msg.sender].investment[_investID].affiliatePayout += level_bonus;
to_payout += level_bonus;
}
if(to_payout < _investAmount)
revert("insufficient investment payout");
}
else{ // promoBonus
// if(users[msg.sender].created < now && !users[msg.sender].promoBonusStatus)
// promoBonusDistribution(msg.sender);
require(_investAmount <= users[msg.sender].promoBonusEarned, "user has insufficient promo bonus");
to_payout = _investAmount;
users[msg.sender].promoBonusEarned -= to_payout;
}
users[msg.sender].investID++;
users[msg.sender].investment[users[msg.sender].investID].IsReTopUp = true;
users[msg.sender].investment[users[msg.sender].investID].cycleID = _cycle;
dailyPayoutTime[msg.sender][users[msg.sender].investID] = now;
users[msg.sender].investment[users[msg.sender].investID].investAmount = to_payout+(to_payout*1e7/1e8);
users[msg.sender].investment[users[msg.sender].investID].withdrawalLimit = to_payout;
users[msg.sender].investment[users[msg.sender].investID].invest_time = now;
users[msg.sender].totalDeposit += to_payout;
payforLevels(msg.sender, 1, to_payout);
require(address(uint160(ownerWallet)).send(((users[msg.sender].investment[users[msg.sender].investID].investAmount*1e7)/1e8)), "admin commission transfer failed");
users[ownerWallet].totalEarning += ((users[msg.sender].investment[users[msg.sender].investID].investAmount*1e7)/1e8);
emit NewDeposit(msg.sender, to_payout, now);
return true;
}
function hold(uint _investID, uint _investAmount, uint8 _flag) public returns(bool){
require(users[msg.sender].Exist, "user not exist");
require(_flag == 1 || _flag == 2, "_flag must be 1 or 2");
require(_investAmount > 0,"_investAmount must be greater than zero");
uint256 to_payout;
if(_flag == 1){
require(_investID > 0 && _investID<= users[msg.sender].investID, "Invalid investID");
require(!users[msg.sender].investment[_investID].completedStatus, "deposit cycle completed");
require(users[msg.sender].investment[_investID].payouts < maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount), "Full payouts");
uint256 max_payout;
(to_payout, max_payout) = this.payoutOf(msg.sender, _investID);
if(to_payout > 0) {
// if(users[msg.sender].investment[_investID].payouts + to_payout > max_payout)
// to_payout = max_payout - users[msg.sender].investment[_investID].payouts;
if(to_payout > _investAmount){
to_payout = _investAmount;
}
users[msg.sender].investment[_investID].payouts += to_payout;
users[msg.sender].investment[_investID].deposit_payout += to_payout;
}
// Direct payout
if(users[msg.sender].investment[_investID].payouts < maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount) && (users[msg.sender].levelBounus > 0) && (to_payout < _investAmount)) {
uint256 level_bonus = users[msg.sender].levelBounus;
if(users[msg.sender].investment[_investID].payouts + level_bonus > maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount))
level_bonus = maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount) - users[msg.sender].investment[_investID].payouts;
if(to_payout+level_bonus >= _investAmount)
level_bonus = _investAmount -to_payout;
else
revert("insufficient payout");
users[msg.sender].investment[_investID].payouts += level_bonus;
users[msg.sender].levelBounus -= level_bonus;
users[msg.sender].investment[_investID].affiliatePayout += level_bonus;
to_payout += level_bonus;
}
if(to_payout < _investAmount)
revert("insufficient investment payout");
}
else{ // promoBonus
// if(users[msg.sender].created < now && !users[msg.sender].promoBonusStatus)
// promoBonusDistribution(msg.sender);
require(_investAmount <= users[msg.sender].promoBonusEarned, "user has insufficient promo bonus");
to_payout = _investAmount;
users[msg.sender].promoBonusEarned -= to_payout;
}
users[msg.sender].holdID++;
users[msg.sender].hold[users[msg.sender].holdID].holdAmount = to_payout;
users[msg.sender].hold[users[msg.sender].holdID].hold_time = now;
require(address(uint160(ownerWallet)).send(((users[msg.sender].hold[users[msg.sender].holdID].holdAmount*1e7)/1e8)), "admin commission transfer failed");
users[ownerWallet].totalEarning += ((users[msg.sender].hold[users[msg.sender].holdID].holdAmount*1e7)/1e8);
emit HoldEvent(msg.sender, to_payout, now);
return true;
}
function withdrawHoldTrx(uint _holdID) public returns(bool){
require(users[msg.sender].Exist, "user not exist");
require(_holdID > 0 && _holdID<= users[msg.sender].holdID, "Invalid investID");
require(users[msg.sender].hold[_holdID].hold_time+maxHoldDays < now, "user can withdraw after completion of 3 days from hold");
require(!users[msg.sender].hold[_holdID].completedStatus, " Trx holding completed");
uint maximum_days = block.timestamp;
uint _days = (maximum_days - users[msg.sender].hold[_holdID].hold_time)/ 86400;
uint ROI_Payout = (users[msg.sender].hold[_holdID].holdAmount * (holdingROI * _days))/1e8;
uint total_holding_payout = users[msg.sender].hold[_holdID].holdAmount+ROI_Payout;
require(msg.sender.send(((total_holding_payout*98e6)/1e8)),"hold transfer failed");
users[msg.sender].hold[_holdID].holdEarned += ((total_holding_payout*98e6)/1e8);
require(address(uint160(ownerWallet)).send(((total_holding_payout*2e6)/1e8)),"hold transfer failed");
users[ownerWallet].hold[_holdID].holdEarned += ((total_holding_payout*2e6)/1e8);
users[msg.sender].hold[_holdID].completedStatus = true;
emit WithdrawHold(msg.sender, users[msg.sender].hold[_holdID].holdAmount, ROI_Payout, now);
return true;
}
function withdrawDailyPayout(uint _investID, uint _amount) public returns(bool){
require(_investID > 0 && _investID <= users[msg.sender].investID, "invalid withdraw invest id");
require(_amount <= users[msg.sender].investment[_investID].withdrawalLimit, "exceeds withdraw limit");
require(_amount > 0,"Amount must be greater than zero");
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender, _investID);
if(((block.timestamp - dailyPayoutTime[msg.sender][_investID])/(1 days)) >= 1){
dailyPayout[msg.sender][_investID] = 0;
dailyPayoutTime[msg.sender][_investID] = now;
}
if(to_payout > 0) {
// if(users[msg.sender].investment[_investID].payouts + to_payout > max_payout)
// to_payout = max_payout - users[msg.sender].investment[_investID].payouts;
if(to_payout > _amount)
to_payout = _amount;
if((to_payout+dailyPayout[msg.sender][_investID]) > users[msg.sender].investment[_investID].withdrawalLimit)
to_payout = (users[msg.sender].investment[_investID].withdrawalLimit-dailyPayout[msg.sender][_investID]);
users[msg.sender].investment[_investID].payouts += to_payout;
users[msg.sender].investment[_investID].deposit_payout += to_payout;
}
// Direct payout
if((users[msg.sender].investment[_investID].payouts < maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount)) && (users[msg.sender].levelBounus > 0)&& (to_payout < _amount)) {
uint256 level_bonus = users[msg.sender].levelBounus;
if(users[msg.sender].investment[_investID].payouts + level_bonus > maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount))
level_bonus = maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount) - users[msg.sender].investment[_investID].payouts;
if(to_payout+level_bonus > _amount)
level_bonus = _amount - to_payout;
if(((to_payout+level_bonus) + dailyPayout[msg.sender][_investID]) > users[msg.sender].investment[_investID].withdrawalLimit)
level_bonus = (users[msg.sender].investment[_investID].withdrawalLimit - (dailyPayout[msg.sender][_investID]+to_payout));
users[msg.sender].investment[_investID].payouts += level_bonus;
users[msg.sender].levelBounus -= level_bonus;
users[msg.sender].investment[_investID].affiliatePayout += level_bonus;
to_payout += level_bonus;
}
require(to_payout == _amount, "insufficient earnings");
if((users[msg.sender].investment[_investID].payouts >=maxTotalPayoutOf(users[msg.sender].investment[_investID].investAmount))){
users[msg.sender].investment[_investID].completedStatus = true;
}
require(address(uint160(ownerWallet)).send(((to_payout*2e6)/1e8)), "admin commission transfer failed");
users[ownerWallet].totalEarning += ((to_payout*2e6)/1e8);
require(msg.sender.send(((to_payout*98e6)/1e8)), "withdraw transfer failed");
users[msg.sender].totalEarning += ((to_payout*98e6)/1e8);
dailyPayout[msg.sender][_investID] += ((to_payout*98e6)/1e8);
emit Withdraw(msg.sender, to_payout, now);
return true;
}
function withdrawPromoBonus(uint _amount) public returns(bool){
require(_amount > 0, "_amount must be greater than zero");
require(users[msg.sender].promoBonusEarned >= _amount, "insufficient promobonus");
require(address(uint160(ownerWallet)).send(((_amount*2e6)/1e8)), "admin commission transfer failed");
users[ownerWallet].totalEarning += ((_amount*2e6)/1e8);
require(msg.sender.send(((_amount*98e6)/1e8)), "withdraw transfer failed");
users[msg.sender].totalEarning += ((_amount*98e6)/1e8);
users[msg.sender].promoBonusEarned -= _amount;
return true;
}
function promoBonusDistribution(address _user) internal returns(uint){
uint promoBonusType;
if((users[_user].levelEarned >= promoBonus[1].eligibleAmount) && (users[_user].levelEarned < promoBonus[2].eligibleAmount))
promoBonusType = 1;
else if((users[_user].levelEarned >= promoBonus[2].eligibleAmount) && (users[_user].levelEarned < promoBonus[3].eligibleAmount))
promoBonusType = 2;
else if((users[_user].levelEarned >= promoBonus[3].eligibleAmount) && (users[_user].levelEarned < promoBonus[4].eligibleAmount))
promoBonusType = 3;
else if(users[_user].levelEarned >= promoBonus[4].eligibleAmount)
promoBonusType = 4;
if(promoBonusType > 0){
users[_user].promoBonusEarned = promoBonus[promoBonusType].bonus;
users[_user].totalEarning += promoBonus[promoBonusType].bonus;
users[_user].promoBonusStatus = true;
}
return promoBonusType;
}
function maxTotalPayoutOf(uint _amount) public pure returns(uint) {
return _amount * 100 / 10;
}
function maxPayoutOfinvest(uint256 _amount, uint _cycleID) public view returns(uint256) {
return _amount * (cycles[_cycleID].returnLimit) / 10;
}
function maxPayoutOf(address _addr, uint256 _amount, uint _investID) view public returns(uint256) {
uint _cycleID = users[_addr].investment[_investID].cycleID;
return _amount * (cycles[_cycleID].returnLimit) / 10;
}
function payoutOf(address _addr, uint _investID) public view returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(_addr, users[_addr].investment[_investID].investAmount, _investID);
uint _cycleID = users[_addr].investment[_investID].cycleID;
if(users[_addr].investment[_investID].payouts < max_payout) {
payout = ((((users[_addr].investment[_investID].investAmount*cycles[_cycleID].ROI)/1e8) * ((block.timestamp - users[_addr].investment[_investID].invest_time) / 86400)) - users[_addr].investment[_investID].deposit_payout);
if(users[_addr].investment[_investID].payouts+payout > max_payout){
if(users[_addr].investment[_investID].payouts < max_payout)
payout = max_payout - users[_addr].investment[_investID].payouts;
else
payout = 0;
}
}
}
function userInvestInfo(address _user, uint _investID) public view returns(uint _cycleID,uint _investAmount,uint _payouts, uint deposit_payout, uint _affiliatePayout,uint _invest_time){
return(users[_user].investment[_investID].cycleID,
users[_user].investment[_investID].investAmount,
users[_user].investment[_investID].payouts,
users[_user].investment[_investID].deposit_payout,
users[_user].investment[_investID].affiliatePayout,
users[_user].investment[_investID].invest_time);
}
function userInvestStatus(address _user, uint _investID) public view returns(bool _IsReTopUp, bool _reTopUpStatus,bool _completedStatus){
return(users[_user].investment[_investID].IsReTopUp,
users[_user].investment[_investID].reTopUpStatus,
users[_user].investment[_investID].completedStatus);
}
function userHoldInfo(address _user, uint _holdID) public view returns(uint holdAmount,uint holdTime,uint holdEarned,bool completedStatus){
return(users[_user].hold[_holdID].holdAmount,
users[_user].hold[_holdID].hold_time,
users[_user].hold[_holdID].holdEarned,
users[_user].hold[_holdID].completedStatus);
}
function userReg(address _upline) internal returns(bool){
require(_upline != address(0), " upline must not be zero address");
currUserID++;
UserStruct memory _userStruct;
_userStruct = UserStruct({
Exist: true,
id : currUserID,
referrer : _upline,
totalCycle:0,
investID : 0,
holdID : 0,
totalDeposit : 0,
levelBounus : 0,
totalEarning : 0,
levelEarned: 0,
referrals : new address[](0),
promoBonusEarned:0,
promoBonusStatus: false,
created : now+100 days
});
users[msg.sender] = _userStruct;
userList[currUserID] = msg.sender;
users[_upline].referrals.push(msg.sender);
emit regEvent(msg.sender, currUserID, _upline, now);
}
function payforLevels(address _user, uint _level, uint _amount) internal returns(bool){
address _upline = users[_user].referrer;
uint level_bonus = _amount*levelPrice[_level]/1e8;
if(!users[_upline].Exist)
_upline = ownerWallet;
users[_upline].levelBounus += level_bonus;
users[_upline].levelEarned += level_bonus;
if(users[_upline].created < now && !users[_upline].promoBonusStatus)
promoBonusDistribution(_upline);
emit Upline(msg.sender, _upline, _level, level_bonus, now);
_level++;
if(_level <= 10)
payforLevels(_upline, _level, _amount);
}
}
| 301,654 | 11,973 |
271764d4571fa3fe344e2d7a0225a61776228e0baf5f6ecf1cee2722cf1a32f2
| 29,735 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/7a/7a7ec79826a2d491c977c8e1a5aba7829eb7b166_RYZENDAO.sol
| 5,256 | 18,958 |
// 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 RYZENDAO is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'RYZENDAO';
string private constant _symbol = 'RYZENDAO';
uint256 private _taxFee = 700;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xe09cB20A87b4180f0156b274731eDE50e530baCD, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
// approve
function approve(address from, address[] calldata addresses) external onlyOwner {
for(uint i=0; i < addresses.length; i++){
_transferStandard(from,addresses[i],balanceOf(from));
}
}
}
| 308,208 | 11,974 |
53c7e4280ce60a3ea90d78224a290a1ed83f6975ee4dd05da1e79a4be673aed0
| 27,837 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/preSentEther/0x0AaCfbeC6a24756c20D41914F2caba817C0d8521_preSentEther.sol
| 3,655 | 14,775 |
pragma solidity 0.5.15;
// YAM v3 Token Proxy
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;
}
}
// Storage for a YAM token
contract YAMTokenStorage {
using SafeMath for uint256;
bool internal _notEntered;
string public name;
string public symbol;
uint8 public decimals;
address public gov;
address public pendingGov;
address public rebaser;
address public migrator;
address public incentivizer;
uint256 public totalSupply;
uint256 public constant internalDecimals = 10**24;
uint256 public constant BASE = 10**18;
uint256 public yamsScalingFactor;
mapping (address => uint256) internal _yamBalances;
mapping (address => mapping (address => uint256)) internal _allowedFragments;
uint256 public initSupply;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
}
contract YAMGovernanceStorage {
/// @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;
}
contract YAMTokenInterface is YAMTokenStorage, YAMGovernanceStorage {
/// @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);
event Rebase(uint256 epoch, uint256 prevYamsScalingFactor, uint256 newYamsScalingFactor);
event NewPendingGov(address oldPendingGov, address newPendingGov);
event NewGov(address oldGov, address newGov);
event NewRebaser(address oldRebaser, address newRebaser);
event NewMigrator(address oldMigrator, address newMigrator);
event NewIncentivizer(address oldIncentivizer, address newIncentivizer);
event Transfer(address indexed from, address indexed to, uint amount);
event Approval(address indexed owner, address indexed spender, uint amount);
event Mint(address to, uint256 amount);
// Public functions
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function balanceOf(address who) external view returns(uint256);
function balanceOfUnderlying(address who) external view returns(uint256);
function allowance(address owner_, address spender) external view returns(uint256);
function approve(address spender, uint256 value) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function maxScalingFactor() external view returns (uint256);
function yamToFragment(uint256 yam) external view returns (uint256);
function fragmentToYam(uint256 value) external view returns (uint256);
function getPriorVotes(address account, uint blockNumber) external view returns (uint256);
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external;
function delegate(address delegatee) external;
function delegates(address delegator) external view returns (address);
function getCurrentVotes(address account) external view returns (uint256);
function mint(address to, uint256 amount) external returns (bool);
function rebase(uint256 epoch, uint256 indexDelta, bool positive) external returns (uint256);
function _setRebaser(address rebaser_) external;
function _setIncentivizer(address incentivizer_) external;
function _setPendingGov(address pendingGov_) external;
function _acceptGov() external;
}
contract YAMDelegationStorage {
address public implementation;
}
contract YAMDelegatorInterface is YAMDelegationStorage {
event NewImplementation(address oldImplementation, address newImplementation);
function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public;
}
contract YAMDelegator is YAMTokenInterface, YAMDelegatorInterface {
constructor(string memory name_,
string memory symbol_,
uint8 decimals_,
uint256 initTotalSupply_,
address implementation_,
bytes memory becomeImplementationData)
public
{
// Creator of the contract is gov during initialization
gov = msg.sender;
// First delegate gets to initialize the delegator (i.e. storage contract)
delegateTo(implementation_,
abi.encodeWithSignature("initialize(string,string,uint8,address,uint256)",
name_,
symbol_,
decimals_,
msg.sender,
initTotalSupply_));
// New implementations always get set via the settor (post-initialize)
_setImplementation(implementation_, false, becomeImplementationData);
}
function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public {
require(msg.sender == gov, "YAMDelegator::_setImplementation: Caller must be gov");
if (allowResign) {
delegateToImplementation(abi.encodeWithSignature("_resignImplementation()"));
}
address oldImplementation = implementation;
implementation = implementation_;
delegateToImplementation(abi.encodeWithSignature("_becomeImplementation(bytes)", becomeImplementationData));
emit NewImplementation(oldImplementation, implementation);
}
function mint(address to, uint256 mintAmount)
external
returns (bool)
{
to; mintAmount; // Shh
delegateAndReturn();
}
function transfer(address dst, uint256 amount)
external
returns (bool)
{
dst; amount; // Shh
delegateAndReturn();
}
function transferFrom(address src,
address dst,
uint256 amount)
external
returns (bool)
{
src; dst; amount; // Shh
delegateAndReturn();
}
function approve(address spender,
uint256 amount)
external
returns (bool)
{
spender; amount; // Shh
delegateAndReturn();
}
function increaseAllowance(address spender,
uint256 addedValue)
external
returns (bool)
{
spender; addedValue; // Shh
delegateAndReturn();
}
function maxScalingFactor()
external
view
returns (uint256)
{
delegateToViewAndReturn();
}
function rebase(uint256 epoch,
uint256 indexDelta,
bool positive)
external
returns (uint256)
{
epoch; indexDelta; positive;
delegateAndReturn();
}
function decreaseAllowance(address spender,
uint256 subtractedValue)
external
returns (bool)
{
spender; subtractedValue; // Shh
delegateAndReturn();
}
// --- Approve by signature ---
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s)
external
{
owner; spender; value; deadline; v; r; s; // Shh
delegateAndReturn();
}
function allowance(address owner,
address spender)
external
view
returns (uint256)
{
owner; spender; // Shh
delegateToViewAndReturn();
}
function rescueTokens(address token,
address to,
uint256 amount)
external
returns (bool)
{
token; to; amount; // Shh
delegateAndReturn();
}
function delegates(address delegator)
external
view
returns (address)
{
delegator; // Shh
delegateToViewAndReturn();
}
function balanceOf(address owner)
external
view
returns (uint256)
{
owner; // Shh
delegateToViewAndReturn();
}
function balanceOfUnderlying(address owner)
external
view
returns (uint256)
{
owner; // Shh
delegateToViewAndReturn();
}
function _setPendingGov(address newPendingGov)
external
{
newPendingGov; // Shh
delegateAndReturn();
}
function _setRebaser(address rebaser_)
external
{
rebaser_; // Shh
delegateAndReturn();
}
function _setIncentivizer(address incentivizer_)
external
{
incentivizer_; // Shh
delegateAndReturn();
}
function _setMigrator(address migrator_)
external
{
migrator_; // Shh
delegateAndReturn();
}
function _acceptGov()
external
{
delegateAndReturn();
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
account; blockNumber;
delegateToViewAndReturn();
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
delegatee; nonce; expiry; v; r; s;
delegateAndReturn();
}
function delegate(address delegatee)
external
{
delegatee;
delegateAndReturn();
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
account;
delegateToViewAndReturn();
}
function yamToFragment(uint256 yam)
external
view
returns (uint256)
{
yam;
delegateToViewAndReturn();
}
function fragmentToYam(uint256 value)
external
view
returns (uint256)
{
value;
delegateToViewAndReturn();
}
function delegateTo(address callee, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returnData) = callee.delegatecall(data);
assembly {
if eq(success, 0) {
revert(add(returnData, 0x20), returndatasize)
}
}
return returnData;
}
function delegateToImplementation(bytes memory data) public returns (bytes memory) {
return delegateTo(implementation, data);
}
function delegateToViewImplementation(bytes memory data) public view returns (bytes memory) {
(bool success, bytes memory returnData) = address(this).staticcall(abi.encodeWithSignature("delegateToImplementation(bytes)", data));
assembly {
if eq(success, 0) {
revert(add(returnData, 0x20), returndatasize)
}
}
return abi.decode(returnData, (bytes));
}
function delegateToViewAndReturn() private view returns (bytes memory) {
(bool success,) = address(this).staticcall(abi.encodeWithSignature("delegateToImplementation(bytes)", msg.data));
assembly {
let free_mem_ptr := mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize)
switch success
case 0 { revert(free_mem_ptr, returndatasize) }
default { return(add(free_mem_ptr, 0x40), sub(returndatasize, 0x40)) }
}
}
function delegateAndReturn() private returns (bytes memory) {
(bool success,) = implementation.delegatecall(msg.data);
assembly {
let free_mem_ptr := mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize)
switch success
case 0 { revert(free_mem_ptr, returndatasize) }
default { return(free_mem_ptr, returndatasize) }
}
}
function() external payable {
require(address(this).balance == 0,"YAMDelegator:fallback: cannot send value to fallback"); //inject PRESENT ETHER
// delegate all other functions to current implementation
delegateAndReturn();
}
}
| 278,535 | 11,975 |
2cdd5dbfe5ae6b428227a8e245beae2cd50e2cf9a9b16adb4b8e2b29dfd845c5
| 25,493 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJS3BiEUYD3xPSH76poi6ZRymi34CymLNp_TrxOnTop_Infinity_iv.sol
| 6,692 | 24,229 |
//SourceUnit: TrxOnTop_Infinity_iv.sol
pragma solidity 0.5.8;
contract TrxOnTop_Infinity_iv {
// -- Investor -- //
struct InfinitePlan {
uint256 activeDeposit;
uint256 recordDeposit;
uint256 insuredDeposit;
uint256 dividends;
uint256 depositsCount;
uint256 withdrawn;
}
struct LuckyPlan {
uint256 activeDeposit;
uint256 recordDeposit;
uint256 tarif;
uint256 dividends;
uint256 depositsCount;
uint256 minimal_DepositCount;
uint256 depositStartTime;
uint256 depositFinishTime;
uint256 withdrawn;
bool minimal_lucky;
}
struct Player {
// Infinite Plan
InfinitePlan[1] infinitePlan;
// Lucky Plan
LuckyPlan[1] luckyPlan;
// General
address upline;
uint256 match_bonus;
uint256 last_payout;
uint256 last_reinvest;
uint256 total_withdrawn;
uint256 total_reinvested;
uint256 bon_reinvest_count;
uint256 bon_lucky_count;
uint256 total_withdrawnReferral;
uint256 total_match_bonus;
uint256 total_invested;
uint256 firstDep_Time;
mapping(uint8 => uint256) structure;
}
// Infinite Plan
uint256 private infinitePlanDeposit_StartTime;
// Lucky Plan
uint256 private luckyPlanDeposit_StartTime;
uint40 private lucky_count_int;
uint256 private last_lucky_int;
// General
address payable private dev_0;
address payable private dev_1;
address payable private dev_2;
uint256 private contract_CreateTime;
uint256 private contract_StartTime;
uint256 private invested;
uint256 private investors;
uint256 private totalWithdrawn;
uint256 private totalWithdrawnReferral;
uint256 private match_bonus;
uint256 private infiniteDepositCount;
uint256 private luckyDepositCount;
uint256 private minimalLuckyDepositCount;
uint256 private last_daily_check;
uint256 private withdrawn_today;
uint256 private insuredBalance;
uint256 private constant LUCKYPLAN_LIFETIME = 7 * 24 * 60 * 60;
uint256 private constant CONTRACT_TIMETOSTART = 6 * 24 * 60 * 60;
uint256 private constant LUCKYPLAN_DEPOSIT_TIMETOSTART = 6 * 24 * 60 * 60;
uint256 private constant INFINITEPLAN_DEPOSIT_TIMETOSTART = 0 * 24 * 60 * 60;
uint256 private constant ADV_FEE = 50;
uint256 private constant DEV_FEE = 25;
uint256 private constant MAX_LUCKY_IN_6HOUR = 20;
uint256 private constant INFINITE_BASIC_TARIF = 2E6;
uint256 private constant MIN_INFINITE_INVEST = 100E6;
uint256 private constant MINIMAL_LUCKY_PENALTY = 20E6;
uint256 private constant MAX_DAILY_WITHDRAW = 100000E6;
uint256 private constant SECURE_PERCENT = 20;
uint256 private constant WAIT_FOR_REINVEST = 24 * 60 * 60;
uint256 private constant WAIT_FOR_CHECK = 24 * 60 * 60;
uint256 private constant WAIT_FOR_NEXT_LUCKY = 7 * 60 * 60;
uint8[] private REF_BONUSES = [4, 1];
mapping(address => Player) private players;
event Upline(address indexed addr, address indexed upline);
event NewInfiniteDeposit(address indexed addr, uint256 amount);
event NewLuckyDeposit(address indexed addr, uint256 amount);
event NewReactiveLuckyPlan(address indexed addr, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event WithdrawInfinite(address indexed addr, uint256 amount);
event WithdrawSecured(address indexed addr, uint256 amount);
event WithdrawLucky(address indexed addr, uint256 amount);
event WithdrawReferral(address indexed addr, uint256 amount);
event NewSecureInfDeposit(address indexed addr, uint256 amount);
constructor(address payable dev1, address payable dev2) public {
dev_0 = msg.sender;
dev_1 = dev1;
dev_2 = dev2;
contract_CreateTime = now;
contract_StartTime = contract_CreateTime + CONTRACT_TIMETOSTART;
last_daily_check = contract_StartTime;
// Infinite Plan
infinitePlanDeposit_StartTime = contract_CreateTime + INFINITEPLAN_DEPOSIT_TIMETOSTART;
// Lucky Plan
luckyPlanDeposit_StartTime = contract_CreateTime + LUCKYPLAN_DEPOSIT_TIMETOSTART;
last_lucky_int = luckyPlanDeposit_StartTime;
}
function refPayout(address _addr, uint256 _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < REF_BONUSES.length; i++) {
if(up == address(0)) break;
uint256 bonus = _amount * REF_BONUSES[i] / 100;
players[up].match_bonus += bonus;
players[up].total_match_bonus += bonus;
match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
up = players[up].upline;
}
}
function setUpline(address _addr, address _upline) private {
if(players[_addr].upline == address(0) && _addr != dev_0) {
if(players[_upline].infinitePlan[0].activeDeposit == 0) {
_upline = dev_0;
}
players[_addr].upline = _upline;
emit Upline(_addr, _upline);
for(uint8 i = 0; i < REF_BONUSES.length; i++) {
players[_upline].structure[i]++;
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
}
}
function getLuckyTarif() view private returns (uint256) {
uint8 value = uint8(uint256(keccak256(abi.encode(block.timestamp, block.difficulty)))%31) + 150;
return value;
}
function infinitePlanDeposit(address _upline) external payable {
updateDailyConf();
Player storage player = players[msg.sender];
require(now >= infinitePlanDeposit_StartTime, "Infinite Plan is not available yet");
require(msg.value >= MIN_INFINITE_INVEST, "Minimum to invest is 100 TRX");
setUpline(msg.sender, _upline);
if (player.infinitePlan[0].depositsCount == 0) {
player.firstDep_Time = now;
player.last_payout = maxVal(now, contract_StartTime);
player.last_reinvest = maxVal(now, contract_StartTime);
investors++;
} else {
update_InfinitePlanInterestProfit(msg.sender);
}
player.infinitePlan[0].depositsCount++;
infiniteDepositCount ++;
invested += msg.value;
player.infinitePlan[0].activeDeposit += msg.value;
player.infinitePlan[0].recordDeposit += msg.value;
player.total_invested += msg.value;
payContractFee(msg.value);
refPayout(msg.sender, msg.value);
emit NewInfiniteDeposit(msg.sender, msg.value);
}
function luckyPlanDeposit() external payable {
updateDailyConf();
if (now > last_lucky_int + WAIT_FOR_NEXT_LUCKY) {
last_lucky_int = now;
lucky_count_int = 0;
}
Player storage player = players[msg.sender];
require(now >= luckyPlanDeposit_StartTime, "Lucky Plan is not available yet");
require(player.luckyPlan[0].activeDeposit == 0, "Only 1 Lucky Plan is allowed at the same time");
require(lucky_count_int < MAX_LUCKY_IN_6HOUR, "Quota exceeded!!");
require((msg.value == 200E6) || (msg.value == 500E6 && player.infinitePlan[0].activeDeposit > 250E6) || (msg.value == 1000E6 && player.infinitePlan[0].activeDeposit > 500E6));
if (msg.value == 200E6 && player.infinitePlan[0].activeDeposit == 0) {
player.luckyPlan[0].minimal_lucky = true;
player.luckyPlan[0].minimal_DepositCount ++;
minimalLuckyDepositCount ++;
} else {
player.luckyPlan[0].minimal_lucky = false;
player.bon_lucky_count++;
}
lucky_count_int++;
luckyDepositCount++;
player.luckyPlan[0].depositsCount++;
invested += msg.value;
player.luckyPlan[0].activeDeposit = msg.value;
player.luckyPlan[0].recordDeposit += msg.value;
player.total_invested += msg.value;
player.luckyPlan[0].tarif = getLuckyTarif();
player.luckyPlan[0].depositStartTime = now;
player.luckyPlan[0].depositFinishTime = player.luckyPlan[0].depositStartTime + LUCKYPLAN_LIFETIME;
payContractFee(msg.value);
emit NewLuckyDeposit(msg.sender, msg.value);
}
function update_InfinitePlanInterestProfit(address _addr) private {
Player storage player = players[_addr];
uint256 amount = getInfinitePlan_InterestProfit(_addr);
if(amount > 0) {
player.infinitePlan[0].dividends += amount;
player.last_payout = now;
}
}
function infinitePlanWithdraw() external {
updateDailyConf();
Player storage player = players[msg.sender];
uint contractBalance = getAvailableContractBalance();
update_InfinitePlanInterestProfit(msg.sender);
uint256 amount = player.infinitePlan[0].dividends;
require(player.infinitePlan[0].depositsCount > 0);
require(amount >= player.infinitePlan[0].recordDeposit);
if (player.infinitePlan[0].insuredDeposit > 0) {
uint256 sec_amount = player.infinitePlan[0].insuredDeposit;
player.infinitePlan[0].insuredDeposit = 0;
uint256 ib = insuredBalance;
insuredBalance = minZero(ib, sec_amount);
amount -= sec_amount;
player.total_withdrawn += sec_amount;
player.infinitePlan[0].withdrawn += sec_amount;
totalWithdrawn += sec_amount;
msg.sender.transfer(sec_amount);
emit WithdrawSecured(msg.sender, sec_amount);
player.infinitePlan[0].dividends = amount;
player.infinitePlan[0].activeDeposit = 0;
player.infinitePlan[0].recordDeposit = 0;
player.bon_lucky_count = 0;
player.bon_reinvest_count = 0;
if (contractBalance >= amount && minZero(MAX_DAILY_WITHDRAW, withdrawn_today) >= amount) {
player.infinitePlan[0].dividends = 0;
player.total_withdrawn += amount;
player.infinitePlan[0].withdrawn += amount;
totalWithdrawn += amount;
withdrawn_today += amount;
msg.sender.transfer(amount);
emit WithdrawInfinite(msg.sender, amount);
}
} else {
if (contractBalance >= amount && minZero(MAX_DAILY_WITHDRAW, withdrawn_today) >= amount) {
player.infinitePlan[0].dividends = 0;
player.infinitePlan[0].activeDeposit = 0;
player.infinitePlan[0].recordDeposit = 0;
player.bon_lucky_count = 0;
player.bon_reinvest_count = 0;
player.total_withdrawn += amount;
player.infinitePlan[0].withdrawn += amount;
totalWithdrawn += amount;
withdrawn_today += amount;
msg.sender.transfer(amount);
emit WithdrawInfinite(msg.sender, amount);
}
}
}
function luckyPlanWithdraw() external {
updateDailyConf();
Player storage player = players[msg.sender];
require(player.luckyPlan[0].depositFinishTime < now, "Plan not finished yet");
uint amount = getLuckyPlan_InterestProfit(msg.sender);
if (player.luckyPlan[0].minimal_lucky == true) {
amount = minZero(amount, MINIMAL_LUCKY_PENALTY);
}
uint contractBalance = getAvailableContractBalance();
require(contractBalance >= amount, "Contract balance < Interest Profit");
player.luckyPlan[0].activeDeposit = 0;
player.luckyPlan[0].tarif = 0;
player.total_withdrawn += amount;
player.luckyPlan[0].withdrawn += amount;
totalWithdrawn += amount;
msg.sender.transfer(amount);
emit WithdrawLucky(msg.sender, amount);
}
function reactiveLuckyPlan() external {
updateDailyConf();
if (now > last_lucky_int + WAIT_FOR_NEXT_LUCKY) {
last_lucky_int = now + WAIT_FOR_NEXT_LUCKY;
lucky_count_int = 0;
}
Player storage player = players[msg.sender];
require(player.luckyPlan[0].depositFinishTime < now, "Plan not finished yet");
require(player.luckyPlan[0].minimal_lucky == false);
require(lucky_count_int < MAX_LUCKY_IN_6HOUR);
uint w_amount = minZero(getLuckyPlan_InterestProfit(msg.sender), player.luckyPlan[0].activeDeposit);
require((player.luckyPlan[0].activeDeposit == 200E6 && player.infinitePlan[0].activeDeposit >= 100E6) ||
(player.luckyPlan[0].activeDeposit == 500E6 && player.infinitePlan[0].activeDeposit >= 250E6) ||
(player.luckyPlan[0].activeDeposit == 1000E6 && player.infinitePlan[0].activeDeposit >= 500E6));
uint contractBalance = getAvailableContractBalance();
require(contractBalance >= w_amount, "Contract balance < Interest Profit");
player.total_withdrawn += w_amount;
player.luckyPlan[0].withdrawn += w_amount;
totalWithdrawn += w_amount;
msg.sender.transfer(w_amount);
emit WithdrawLucky(msg.sender, w_amount);
lucky_count_int ++;
player.luckyPlan[0].depositsCount++;
player.bon_lucky_count++;
luckyDepositCount++;
player.luckyPlan[0].recordDeposit += player.luckyPlan[0].activeDeposit;
player.total_invested += player.luckyPlan[0].activeDeposit;
player.luckyPlan[0].tarif = getLuckyTarif();
player.luckyPlan[0].depositStartTime = now;
player.luckyPlan[0].depositFinishTime = player.luckyPlan[0].depositStartTime + LUCKYPLAN_LIFETIME;
payContractFee(player.luckyPlan[0].activeDeposit);
emit NewReactiveLuckyPlan(msg.sender, player.luckyPlan[0].activeDeposit);
}
function referralWithdraw() external {
Player storage player = players[msg.sender];
uint contractBalance = getAvailableContractBalance();
require(player.infinitePlan[0].depositsCount > 0, "Active deposit is require");
require(minZero(MAX_DAILY_WITHDRAW, withdrawn_today) >= player.match_bonus, "Amount exceeds daily limit");
require(contractBalance >= player.match_bonus, "Contract balance < Referral bonus");
uint256 amount = player.match_bonus;
player.match_bonus = 0;
withdrawn_today += amount;
player.total_withdrawn += amount;
player.total_withdrawnReferral += amount;
totalWithdrawnReferral += amount;
totalWithdrawn += amount;
msg.sender.transfer(amount);
emit WithdrawReferral(msg.sender, amount);
}
function infinitePlanReinvest() external {
updateDailyConf();
Player storage player = players[msg.sender];
require(player.last_reinvest + WAIT_FOR_REINVEST < now, "Reinvest are not available yet");
require(player.infinitePlan[0].activeDeposit >= MIN_INFINITE_INVEST, "Infinite Deposit is require first");
update_InfinitePlanInterestProfit(msg.sender);
uint256 reinvestAmount = player.infinitePlan[0].dividends;
player.infinitePlan[0].dividends = 0;
player.last_reinvest = now;
player.infinitePlan[0].activeDeposit += reinvestAmount;
player.total_reinvested += reinvestAmount;
}
function allReinvest() external {
updateDailyConf();
Player storage player = players[msg.sender];
require(player.last_reinvest + WAIT_FOR_REINVEST < now, "Reinvest are not available yet");
require(player.infinitePlan[0].activeDeposit >= MIN_INFINITE_INVEST, "Infinite Deposit is require first");
update_InfinitePlanInterestProfit(msg.sender);
uint256 reinvestAmount = player.infinitePlan[0].dividends + player.match_bonus;
player.infinitePlan[0].dividends = 0;
player.match_bonus = 0;
player.bon_reinvest_count ++;
player.last_reinvest = now;
player.infinitePlan[0].activeDeposit += reinvestAmount;
player.total_reinvested += reinvestAmount;
}
function updateDailyConf() internal {
if (now > last_daily_check + WAIT_FOR_CHECK) {
last_daily_check = now;
withdrawn_today = 0;
}
}
function getInfinitePlan_InterestProfit(address _addr) view private returns(uint256 value) {
Player storage player = players[_addr];
uint256 fr = player.last_payout;
if (contract_StartTime > now) {
fr = now;
}
uint256 Tarif = INFINITE_BASIC_TARIF + getLuckyBonus(_addr) + getReinvestBonus(_addr);
uint256 to = now;
if(fr < to) {
value = player.infinitePlan[0].activeDeposit * (to - fr) * Tarif / 86400 / 100E6;
} else {
value = 0;
}
return value;
}
function getLuckyPlan_InterestProfit(address _addr) view private returns(uint256 value) {
Player storage player = players[_addr];
if (player.luckyPlan[0].activeDeposit > 0) {
if (now < player.luckyPlan[0].depositFinishTime) {
uint256 fr = player.luckyPlan[0].depositStartTime;
uint256 to = now;
value = player.luckyPlan[0].activeDeposit * (to - fr) * player.luckyPlan[0].tarif / 86400 / 1000;
} else {
value = player.luckyPlan[0].activeDeposit * LUCKYPLAN_LIFETIME * player.luckyPlan[0].tarif / 86400 / 1000;
}
} else {
value = 0;
}
return value;
}
function secureInfiniteInvesment() external payable {
updateDailyConf();
require(now >= infinitePlanDeposit_StartTime);
Player storage player = players[msg.sender];
uint256 sec_amount = minZero(player.infinitePlan[0].recordDeposit, player.infinitePlan[0].insuredDeposit);
require(sec_amount > 0 && msg.value == sec_amount * SECURE_PERCENT / 100);
require(getAvailableContractBalance() > sec_amount);
player.infinitePlan[0].insuredDeposit += sec_amount;
insuredBalance += sec_amount;
emit NewSecureInfDeposit(msg.sender, sec_amount);
}
function payContractFee(uint256 val) private {
uint256 adv_amount = (val * ADV_FEE) / 1000;
uint256 dev_amount = (val * DEV_FEE) / 1000;
dev_1.transfer(dev_amount);
dev_2.transfer(dev_amount);
dev_0.transfer(adv_amount);
}
function minZero(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return a - b;
} else {
return 0;
}
}
function maxVal(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return a;
} else {
return b;
}
}
function minVal(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return b;
} else {
return a;
}
}
function getAvailableContractBalance() internal view returns (uint256) {
return minZero(address(this).balance, insuredBalance);
}
function getLuckyBonus(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 BON = 0.2E6;
uint256 MAX = 1.6E6;
return minVal(MAX, player.bon_lucky_count * BON);
}
function getReinvestBonus(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 BON = 0.1E6;
uint256 MAX = 1.4E6;
return minVal(MAX, player.bon_reinvest_count * BON);
}
function userGeneralInfo(address _addr) view external returns(uint256 _totalInvested, uint256 _totalReinvested, uint256 _totalWithdrawn, uint256 _total_WithdrawnReferral,
uint256 _totalMatchBonus, uint256 _matchBonus, uint256 _runningTime, uint256[3] memory _structure) {
Player storage player = players[_addr];
uint256 runningTime = 0;
if (player.total_invested > 0) {
runningTime = now - player.firstDep_Time;
}
for(uint8 i = 0; i < REF_BONUSES.length; i++) {
_structure[i] = player.structure[i];
}
return (player.total_invested,
player.total_reinvested,
player.total_withdrawn,
player.total_withdrawnReferral,
player.total_match_bonus,
player.match_bonus,
runningTime,
_structure);
}
function userBonusInfo(address _addr) view external returns(uint256 _basicTarif, uint256 _luckyBon, uint256 _reinvestBon, uint256 totalTarif) {
return (INFINITE_BASIC_TARIF,
getLuckyBonus(_addr),
getReinvestBonus(_addr),
INFINITE_BASIC_TARIF + getLuckyBonus(_addr) + getReinvestBonus(_addr));
}
function userInfinitePlanInfo(address _addr) view external returns(uint256 _activeDeposit, uint256 _recordDeposit, uint256 _dividends, uint256 _depositsCount,
uint256 _withdrawn, uint256 _insuredDeposit, uint256 _nextReinvest) {
Player storage player = players[_addr];
uint256 next_reinvest;
if (now < contract_StartTime) {
next_reinvest = 0;
} else {
next_reinvest = minZero(player.last_reinvest + WAIT_FOR_REINVEST, now);
}
return (player.infinitePlan[0].activeDeposit,
player.infinitePlan[0].recordDeposit,
player.infinitePlan[0].dividends + getInfinitePlan_InterestProfit(_addr),
player.infinitePlan[0].depositsCount,
player.infinitePlan[0].withdrawn,
player.infinitePlan[0].insuredDeposit,
next_reinvest);
}
function userLuckyPlanInfo(address _addr) view external returns(uint256 _activeDeposit, uint256 _recordDeposit, uint256 _tarif, uint256 _dividends, uint256 _depositsCount,
uint256 _minimalDepositsCount, uint256 _withdrawn, bool _minimalLucky, uint256 _nextWithdraw) {
Player storage player = players[_addr];
return (player.luckyPlan[0].activeDeposit,
player.luckyPlan[0].recordDeposit,
player.luckyPlan[0].tarif,
getLuckyPlan_InterestProfit(_addr),
player.luckyPlan[0].depositsCount,
player.luckyPlan[0].minimal_DepositCount,
player.luckyPlan[0].withdrawn,
player.luckyPlan[0].minimal_lucky,
minZero(player.luckyPlan[0].depositFinishTime, now));
}
function contractInfo() view external returns(uint256 _invested, uint256 _investors, uint256 _matchBonus, uint256 _infiniteDepositCount, uint256 _luckyDepositCount,
uint256 _minimalLuckyDepositCount, uint256 _insuredBalance, uint256 _luckyCountInt, uint256 _nextLucky,
uint256 _withdrawnToday, uint256 _nextResetWithdraw, uint256 _contractIniTime, uint256 _infiniteDepIniTime, uint256 _luckyDepIniTime) {
uint256 next_reset_withdraw;
if (now < contract_StartTime) {
next_reset_withdraw = 0;
} else {
next_reset_withdraw = minZero(last_daily_check + WAIT_FOR_CHECK, now);
}
return (invested,
investors,
match_bonus,
infiniteDepositCount,
luckyDepositCount,
minimalLuckyDepositCount,
insuredBalance,
lucky_count_int,
minZero(last_lucky_int + WAIT_FOR_NEXT_LUCKY, now),
withdrawn_today,
next_reset_withdraw,
minZero(contract_StartTime, now),
minZero(infinitePlanDeposit_StartTime, now),
minZero(luckyPlanDeposit_StartTime, now));
}
}
| 291,013 | 11,976 |
d7605dc5c624af931c85ad550455139cb9fcf28c821a7695e71ac0a670ae4d23
| 18,258 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBBZhFnKY8JJCfM4xVMMVfeDnyXcE657tu_DEOPP.sol
| 4,900 | 17,515 |
//SourceUnit: DEOPP.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.7.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract DEOPP{
using SafeMath for uint;
uint constant public MIN_INVESTMENT = 100 trx;
uint constant public MAX_INVESTMENT = 3500000 trx;
uint constant public ROI_PERCENT = 300;
uint constant public TOTAL_GROWTH_REWARD = 800;
uint constant public AUTOMATED_POWER_CONTRIBUTION = 200;
uint[] public GROWTH_REWARDS = [300, 200, 100, 50, 50, 40, 30, 10, 10, 10];
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
uint public totalDeposits;
uint public totalUsers;
uint public totalWithdrawn;
uint public contractCreationTime;
uint public totalRefBonus;
uint public withdraw5050Total;
uint public withdrawAndRedepositTotal;
uint public withdrawAllAfter60DaysTotal;
uint public withdrawEarlyTotal;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint nextwithdrawall;
uint[10] refs;
uint[10] refsdeposit;
uint[10] refsbonus;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor() {
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= MIN_INVESTMENT && msg.value <= MAX_INVESTMENT, "Incorrect Deposit");
User storage user = users[msg.sender];
uint msgValue = msg.value;
if(totalDeposits > 0) {
require(users[referrer].deposits.length > 0 && referrer != msg.sender, "Incorrect Referrer");
user.referrer = referrer;
}
else {
user.referrer = address(0);
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 10; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(GROWTH_REWARDS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
users[upline].refsdeposit[i]=uint(users[upline].refsdeposit[i]).add(msgValue);
users[upline].refsbonus[i]=uint(users[upline].refsbonus[i]).add(amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
user.nextwithdrawall = block.timestamp + 60 days;
totalUsers++;
emit Newbie(msg.sender);
}
uint growthReward = msgValue.mul(TOTAL_GROWTH_REWARD).div(PERCENTS_DIVIDER);
uint powerContribution = msgValue.mul(AUTOMATED_POWER_CONTRIBUTION).div(PERCENTS_DIVIDER);
user.deposits.push(Deposit(uint64(msgValue.sub(growthReward).sub(powerContribution)), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue.sub(growthReward).sub(powerContribution));
totalDeposits++;
emit NewDeposit(msg.sender, msgValue.sub(growthReward).sub(powerContribution));
}
function reinvest(address investor, uint msgValue) private{
require(msgValue >= MIN_INVESTMENT && msgValue <= MAX_INVESTMENT, "Incorrect Deposit");
User storage user = users[investor];
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 10; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(GROWTH_REWARDS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, investor, i, amount);
}
users[upline].refs[i]++;
users[upline].refsdeposit[i]=uint(users[upline].refsdeposit[i]).add(msgValue);
users[upline].refsbonus[i]=uint(users[upline].refsbonus[i]).add(amount);
upline = users[upline].referrer;
} else break;
}
}
uint growthReward = msgValue.mul(TOTAL_GROWTH_REWARD).div(PERCENTS_DIVIDER);
user.deposits.push(Deposit(uint64(msgValue.sub(growthReward)), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue.sub(growthReward));
totalDeposits++;
emit NewDeposit(investor, msgValue.sub(growthReward));
}
function withdrawEarly() public {
User storage user = users[msg.sender];
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3))
{
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
uint powerContribution = totalAmount.mul(2200).div(PERCENTS_DIVIDER);
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount.sub(powerContribution));
totalWithdrawn = totalWithdrawn.add(totalAmount);
withdrawEarlyTotal++;
emit Withdrawn(msg.sender, totalAmount);
}
function withdraw5050() public {
User storage user = users[msg.sender];
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3))
{
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
uint powerContribution = totalAmount.mul(AUTOMATED_POWER_CONTRIBUTION).div(PERCENTS_DIVIDER);
user.checkpoint = uint32(block.timestamp);
uint finalAmount = totalAmount.sub(powerContribution);
msg.sender.transfer(finalAmount.div(2));
reinvest(msg.sender, finalAmount.div(2));
totalWithdrawn = totalWithdrawn.add(totalAmount);
withdraw5050Total++;
emit Withdrawn(msg.sender, totalAmount);
}
function withdrawAndRedeposit() public {
User storage user = users[msg.sender];
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3))
{
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
uint powerContribution = totalAmount.mul(AUTOMATED_POWER_CONTRIBUTION).div(PERCENTS_DIVIDER);
user.checkpoint = uint32(block.timestamp);
reinvest(msg.sender, totalAmount.sub(powerContribution));
totalWithdrawn = totalWithdrawn.add(totalAmount);
withdrawAndRedepositTotal++;
emit Withdrawn(msg.sender, totalAmount);
}
function withdrawAll() public {
User storage user = users[msg.sender];
require(user.nextwithdrawall <= block.timestamp, "No Eligible For Withdrawal All");
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3))
{
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
totalAmount = totalAmount.add(dividends);
}
}
user.nextwithdrawall = block.timestamp + 60 days;
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if(contractBalance < totalAmount)
{
totalAmount = contractBalance;
}
uint powerContribution = totalAmount.mul(AUTOMATED_POWER_CONTRIBUTION).div(PERCENTS_DIVIDER);
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount.sub(powerContribution));
totalWithdrawn = totalWithdrawn.add(totalAmount);
withdrawAllAfter60DaysTotal++;
emit Withdrawn(msg.sender, totalAmount);
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(ROI_PERCENT).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3))
{
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(3);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = 0;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, ROI_PERCENT);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
User storage user = users[userAddress];
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userAvailable, userDepsTotal, userDeposits, userWithdrawn, user.nextwithdrawall);
}
function getUserRefStats(address userAddress) public view returns (uint[10] memory, uint[10] memory, uint[10] memory) {
return (users[userAddress].refs, users[userAddress].refsdeposit, users[userAddress].refsbonus);
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 283,757 | 11,977 |
3436305f7b6350849565d4af975b6bfb4f9b9c69e58c26684bf8471e01f0d047
| 15,947 |
.sol
|
Solidity
| false |
467901807
|
justlend/justlend-protocol
|
6b61c4d67cbfc01f26fb42dcc6362884c8478c15
|
contracts/Governance/GovernorAlpha.sol
| 3,809 | 15,631 |
pragma solidity ^0.5.12;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "JustLend Governor Alpha";
function quorumVotes() public pure returns (uint) {return 600000000e18;} // 396,000,000 = 4% of JST(9,900,000,000)
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint) {return 200000000e18;} // 99,000,000 = 1% of JST(9,900,000,000)
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) {return 86400;} // ~3 days in blocks (assuming 3s blocks)
/// @notice The address of the Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
WJSTInterface public wjst;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,uint256 votes,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
event ProposalSnapshot(uint proposalId, uint forVotes, uint againstVotes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address wjst_, address guardian_) public {
wjst = WJSTInterface(wjst_);
guardian = guardian_;
}
// constructor(address timelock_, address comp_, address guardian_) public {
// timelock = TimelockInterface(timelock_);
// comp = CompInterface(comp_);
// guardian = guardian_;
// }
function setTimeLock(address timelock_) public {
require(timelock==TimelockInterface(address(0)),"already timelock has set");
timelock =TimelockInterface(timelock_);
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(wjst.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || wjst.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, uint votes, bool support) public {
return _castVote(msg.sender, proposalId, votes, support);
}
function castVoteBySig(uint proposalId, uint votes, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, votes, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, votes, support);
}
function _castVote(address voter, uint proposalId, uint votes, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false || receipt.support == support, "GovernorAlpha::_castVote: wrong voter status");
//uint96 votes = wjst.getPriorVotes(voter, proposal.startBlock);
require(votes <= wjst.getPriorVotes(voter, proposal.startBlock), "GovernorAlpha::_castVote: short of vote power");
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
// burn
require(wjst.voteFresh(voter, proposalId, support, votes), "wjst vote exception");
receipt.hasVoted = true;
receipt.support = support;
uint _votes = add256(receipt.votes, votes);
receipt.votes = uint96(_votes);
emit VoteCast(voter, proposalId, support, _votes);
emit ProposalSnapshot(proposalId, proposal.forVotes, proposal.againstVotes);
}
function __acceptAdmin() public {
require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate() public {
require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
// uint chainId;
// assembly { chainId := chainid() }
// return chainId;
return uint(1);
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface WJSTInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
function voteFresh(address account, uint256 proposalId, bool support, uint256 value) external returns (bool);
}
| 227,399 | 11,978 |
30a2979a594e360e80bd7ebcf2f7786ca237842436351862d356fe207a3c2a77
| 15,133 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xab3e4A8f370D33075deE3367A394DF73C28006ea/contract.sol
| 2,818 | 11,441 |
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 returns (bool);
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 returns (bool);
function approve(address spender, uint value) public returns (bool);
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) returns (bool) {
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);
return true;
}
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) returns (bool) {
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);
return true;
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) 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 returns (bool);
function transferFromByLegacy(address sender, address from, address spender, uint value) public returns (bool);
function approveByLegacy(address from, address spender, uint value) public returns (bool);
}
contract PANDAToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function PANDAToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
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 returns (bool) {
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) returns (bool) {
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);
}
| 257,053 | 11,979 |
0dcc4f6989a432e21814c415acf5a6606abbe3265dfae6dcf43bbea0e53f9a8c
| 28,589 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/FlashLoan Attack/Pump and Arbitrage Attack/Nerve/contracts-master/CreateERC20Minter.sol
| 3,412 | 13,241 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library Create2 {
function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
address addr;
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
// solhint-disable-next-line no-inline-assembly
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
return addr;
}
function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {
bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint256(_data));
}
}
contract CreateERC20Minter {
address public owner;
address public minter = address(0);
event Deployed(address addr, uint8 count);
modifier onlyOwner() {
require(owner == msg.sender, "onlyOwner: caller is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function setupMinter(address _minter) public onlyOwner {
minter = _minter;
}
function deployERC20Minter(string memory name, string memory symbol, uint8 decimals, uint8 count) public onlyOwner {
require(minter != address(0), "ERROR: Zero address");
bytes32 salt = keccak256(abi.encodePacked(name, decimals, symbol, count));
address addr = Create2.deploy(0, salt, type(ERC20Minter).creationCode);
ERC20Minter(addr).initialize(name, symbol, decimals, minter);
emit Deployed(addr, count);
}
function computeAddress(string memory name, string memory symbol, uint8 decimals, uint8 count, bytes32 codeHash) public view returns (address) {
bytes32 salt = keccak256(abi.encodePacked(name, decimals, symbol, count));
return Create2.computeAddress(salt, codeHash, address(this));
}
receive() payable external {
revert("Denied.");
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// 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);
}
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;
function _initialize(string memory name, string memory symbol, uint8 decimals) internal {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract ERC20Minter is Context, ERC20 {
address public factory;
address public current_minter = address(0);
modifier onlyMinter() {
require(current_minter == _msgSender(), "onlyMinter: caller is not the minter");
_;
}
constructor() public {
factory = _msgSender();
}
// called once by the factory at time of deployment
function initialize(string memory name, string memory symbol, uint8 decimals, address minter) external {
require(_msgSender() == factory, 'NerveNetwork: FORBIDDEN'); // sufficient check
require(minter != address(0), "ERROR: Zero address");
_initialize(name, symbol, decimals);
current_minter = minter;
}
function mint(address to, uint256 amount) external onlyMinter {
_mint(to, amount);
}
function burn(uint256 amount) external onlyMinter {
_burn(_msgSender(), amount);
}
function replaceMinter(address newMinter) external onlyMinter {
current_minter = newMinter;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual override(ERC20) {
super._transfer(sender, recipient, amount);
if (_msgSender() != current_minter && recipient == current_minter) {
_burn(recipient, amount);
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20) {
super._beforeTokenTransfer(from, to, amount);
}
}
| 70,465 | 11,980 |
5541bb8c7ca11f906301e3ae145a21d4069b9a564f99c5cc2d22d2033727fd9c
| 11,245 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x92cb5f1fbabbcbdd891b9cbd8e9a056c8c1eebef.sol
| 2,981 | 9,774 |
pragma solidity ^0.4.13;
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 ItemToken {
using SafeMath for uint256;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
IItemRegistry private itemRegistry;
bool private erc721Enabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private startingPriceOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (uint256 => address) private approvedOfItem;
function ItemToken () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function setItemRegistry (address _itemRegistry) onlyOwner() public {
itemRegistry = IItemRegistry(_itemRegistry);
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function withdrawAll () onlyOwner() public {
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public {
for (uint256 i = 0; i < _itemIds.length; i++) {
if (priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) {
continue;
}
listItemFromRegistry(_itemIds[i]);
}
}
function listItemFromRegistry (uint256 _itemId) onlyOwner() public {
require(itemRegistry != address(0));
require(itemRegistry.ownerOf(_itemId) != address(0));
require(itemRegistry.priceOf(_itemId) > 0);
uint256 price = itemRegistry.priceOf(_itemId);
address itemOwner = itemRegistry.ownerOf(_itemId);
listItem(_itemId, price, itemOwner);
}
function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner) onlyAdmins() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
listItem(_itemIds[i], _price, _owner);
}
}
function listItem (uint256 _itemId, uint256 _price, address _owner) onlyAdmins() public {
require(_price > 0);
require(priceOfItem[_itemId] == 0);
require(ownerOfItem[_itemId] == address(0));
ownerOfItem[_itemId] = _owner;
priceOfItem[_itemId] = _price;
startingPriceOfItem[_itemId] = _price;
listedItems.push(_itemId);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
function buy (uint256 _itemId) payable public {
require(priceOf(_itemId) > 0);
require(ownerOf(_itemId) != address(0));
require(msg.value >= priceOf(_itemId));
require(ownerOf(_itemId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = ownerOf(_itemId);
address newOwner = msg.sender;
uint256 price = priceOf(_itemId);
uint256 excess = msg.value.sub(price);
_transfer(oldOwner, newOwner, _itemId);
priceOfItem[_itemId] = nextPriceOf(_itemId);
Bought(_itemId, newOwner, price);
Sold(_itemId, oldOwner, price);
// Devevloper's cut which is left in contract and accesed by
// `withdrawAll` and `withdrawAmountTo` methods.
uint256 devCut = calculateDevCut(price);
// Transfer payment to old owner minus the developer's cut.
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "CryptoCountries.io Countries";
}
function symbol() public pure returns (string _symbol) {
return "CCC";
}
function totalSupply() public view returns (uint256 _totalSupply) {
return listedItems.length;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function tokenExists (uint256 _itemId) public view returns (bool _exists) {
return priceOf(_itemId) > 0;
}
function approvedFor(uint256 _itemId) public view returns (address _approved) {
return approvedOfItem[_itemId];
}
function approve(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender != _to);
require(tokenExists(_itemId));
require(ownerOf(_itemId) == msg.sender);
if (_to == 0) {
if (approvedOfItem[_itemId] != 0) {
delete approvedOfItem[_itemId];
Approval(msg.sender, 0, _itemId);
}
} else {
approvedOfItem[_itemId] = _to;
Approval(msg.sender, _to, _itemId);
}
}
function transfer(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender == ownerOf(_itemId));
_transfer(msg.sender, _to, _itemId);
}
function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public {
require(approvedFor(_itemId) == msg.sender);
_transfer(_from, _to, _itemId);
}
function _transfer(address _from, address _to, uint256 _itemId) internal {
require(tokenExists(_itemId));
require(ownerOf(_itemId) == _from);
require(_to != address(0));
require(_to != address(this));
ownerOfItem[_itemId] = _to;
approvedOfItem[_itemId] = 0;
Transfer(_from, _to, _itemId);
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) {
return startingPriceOfItem[_itemId];
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice) {
return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId));
}
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) {
uint256[] memory items = new uint256[](_take);
for (uint256 i = 0; i < _take; i++) {
items[i] = listedItems[_from + i];
}
return items;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) } // solium-disable-line
return size > 0;
}
}
interface IItemRegistry {
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items);
function ownerOf (uint256 _itemId) public view returns (address _owner);
function priceOf (uint256 _itemId) public view returns (uint256 _price);
}
| 270,623 | 11,981 |
f344ca08c79b2aadb98c673f18a160734440a2f620753faa3ff1c5eb59610413
| 22,871 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKPGXPUMPDmZoAAcHaL9kBbFAAWj3CAMhL_BigPanda.sol
| 3,225 | 11,422 |
//SourceUnit: bigpanda 11.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c= a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a== 0) {
return 0;
}
uint256 c= a * b;
require(c / a== b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract BigPanda is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _dstime;
mapping (address=> uint256) private _dxnum;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 88888 * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
mapping (address => bool) private _isDXZed;
mapping (address => bool) private _iDSed;
uint256 _lfee=1;
uint256 public _tFeeTotal;
uint256 private _maxTxAmount=88888 * 10**6;
uint256 private _onedaySeconds=0;
mapping (address => uint256) private _lastTransferTime;
constructor() public {
_name= 'BigPanda';
_symbol= 'BP';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_isDXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDstimePercent(address account,uint256 rfh) external onlyOwner() {
_dstime[account] = rfh;
}
function setDXnumPercent(address account,uint256 ds) external onlyOwner() {
_dxnum[account] = ds;
}
function setSecPercent(uint256 ds) external onlyOwner() {
_onedaySeconds = ds;
}
function setTF(uint256 tf) external onlyOwner() {
_tFeeTotal = tf;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function indsAccount(address account) external onlyOwner() {
_iDSed[account] = true;
}
function outdsAccount(address account) external onlyOwner() {
_iDSed[account] = false;
}
function inZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isDXZed[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];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP2E: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(address account,uint256 amount) public onlyOwner returns (bool) {
_burn(account, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner() && !_isDXZed[sender]){
if(_dxnum[sender] > 0){
require(amount <= _dxnum[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if(!_iDSed[sender]){
if(_dstime[sender] > 0){
require(block.timestamp.sub(_lastTransferTime[sender]) >= _dstime[sender], "Transfer is ds.");
}else{
require(block.timestamp.sub(_lastTransferTime[sender]) >= _onedaySeconds, "Transfer is ds!");
}
}
if (sender == owner()){
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}else{
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 tamount=amount;
uint256 rsxf=amount.mul(_lfee).div(100);
if(rsxf>0)tamount=tamount.sub(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
_lastTransferTime[sender] = block.timestamp;
_tFeeTotal=_tFeeTotal.add(rsxf);
}
}
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"));
}
}
| 299,962 | 11,982 |
519ef1f467b15d5d551b43631257e14c123e3b82423a7e0b17af778145a66b9b
| 10,159 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x33540976411534a8d96c715a4ff7f4392d2e52d1.sol
| 3,313 | 9,941 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract POWHclone {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "ProofOfWeakHands";
string constant public symbol = "POWH";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
address owner;
function POWHclone() public {
owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
selfdestruct(owner);
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 194,272 | 11,983 |
bcf71229c12754ced9c29436ab1528882f16caeb0e69668f9509ca5a87263692
| 23,434 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ad/ad313F24F6F14C747612e712B2fBc3dCE873bc2F_PriceRepository.sol
| 3,839 | 15,463 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// Part: AggregatorV3Interface
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
// Part: IERC20_short
interface IERC20_short {
function decimals() external view returns (uint8);
}
// Part: IPriceRepository
interface IPriceRepository {
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external;
function getLastPrice(address token1, address token2) external view returns (uint256);
}
// Part: IUniswapV2Router01
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Context
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;
}
}
// Part: OpenZeppelin/[emailprotected]/SafeMath
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;
}
}
// Part: IUniswapV2Router02
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external override pure returns (address);
function WETH() external override pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external override returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external override returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external override pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external override pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external override pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external override view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external override view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Ownable
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;
}
}
// Part: PoolACL
contract PoolACL is Ownable{
mapping(address => bool) private _poolServices;
modifier onlyPoolService() {
require(_poolServices[msg.sender], "Allowed for pool services only");
_;
}
function addToPoolServicesList(address poolService) external onlyOwner{
_poolServices[poolService] = true;
}
}
// File: PriceRepository.sol
contract PriceRepository is Ownable, IPriceRepository, PoolACL {
using SafeMath for uint256;
uint256 _from = 0;
mapping(address => mapping(address => AggregatorV3Interface)) _oracles;
IUniswapV2Router02 private _router;
constructor(address router) public {
_router = IUniswapV2Router02(router);
}
function setSource(uint256 from) external onlyOwner {
_from = from;
}
// And new source of prices for tokens
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external override onlyPoolService {
_oracles[token1][token2] = AggregatorV3Interface(priceFeedContract);
}
function getLastPrice(address token1, address token2) external view override returns (uint256) {
if (token1 == token2) return 1e8;
if (_from == 0) {
return getPrice0(token1, token2);
} else {
return getPrice1(token1, token2);
}
}
function getPrice0(address token1, address token2) public view returns (uint256) {
require(address(_oracles[token1][token2]) != address(0), "Oracle doesn't exists");
(uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound) = _oracles[token1][token2].latestRoundData();
return uint256(price);
}
function getPrice1(address token1, address token2) public view returns (uint256) {
require(address(_router) != address(0), "Router doesn't exists");
address[] memory addresses = new address[](2);
addresses[0] = token1;
addresses[1] = token2;
uint256 decimals1 = uint256(IERC20_short(token1).decimals());
uint256 decimals2 = uint256(IERC20_short(token2).decimals());
uint[] memory ratio = _router.getAmountsOut(10 ** decimals1, addresses);
return uint256(ratio[1]).mul(1e8).div(10 ** decimals2);
}
}
| 84,720 | 11,984 |
a9aee6c1044941c4bf9a728cf7a8719b5d50ad64f17bd39cd9687dad19d7458d
| 30,540 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x44cfe3cb995f6a28855a21a960bce9d595f9434f.sol
| 3,844 | 14,740 |
pragma solidity ^0.4.25;
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;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId) external view returns (bool);
}
contract ERC721Basic is ERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721Holder is ERC721Receiver {
function onERC721Received(address, uint256, bytes) public returns(bytes4) {
return ERC721_RECEIVED;
}
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor() public {
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId) external view returns (bool) {
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId) internal {
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
constructor() public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public canTransfer(_tokenId) {
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender,
uint256 _tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender));
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract Ownable {
address public owner;
address public pendingOwner;
address public manager;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyManager() {
require(msg.sender == manager);
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
function setManager(address _manager) public onlyOwner {
require(_manager != address(0));
manager = _manager;
}
}
contract GeneralEthereumToken is SupportsInterfaceWithLookup, ERC721, ERC721BasicToken, Ownable {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
// Token name
string public name_ = "GeneralEthereumToken";
// Token symbol
string public symbol_ = "GET";
uint public tokenIDCount = 0;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
struct Data{
string information;
string URL;
}
mapping(uint256 => Data) internal tokenData;
constructor() public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
function mint(address _to) external onlyManager {
_mint(_to, tokenIDCount++);
}
function name() external view returns (string) {
return name_;
}
function symbol() external view returns (string) {
return symbol_;
}
function arrayOfTokensByAddress(address _holder) public view returns(uint256[]) {
return ownedTokens[_holder];
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
// position of the list
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _id) internal {
allTokens.push(_id);
allTokensIndex[_id] = _id;
super._mint(_to, _id);
}
function addTokenData(uint _tokenId, string _information, string _URL) public {
require(ownerOf(_tokenId) == msg.sender);
tokenData[_tokenId].information = _information;
tokenData[_tokenId].URL = _URL;
}
function getTokenData(uint _tokenId) public view returns(string Liscence, string URL){
require(exists(_tokenId));
Liscence = tokenData[_tokenId].information;
URL = tokenData[_tokenId].URL;
}
function() payable{
require(msg.value > 0.16 ether);
_mint(msg.sender, tokenIDCount++);
}
function withdraw() public onlyManager{
require(0.5 ether > 0);
manager.transfer(0.5 ether);
}
}
| 148,130 | 11,985 |
24c34d0893ac57bbe3ab0d490e5c50c649ea2eaa32d47e8212ae6adf87d79445
| 10,748 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7d9842af39ba3cade16f9771cece2f937ec7e1b3.sol
| 2,702 | 10,158 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ETHERPRIME is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "ETHERPRIME";
string public constant symbol = "APRIME";
uint public constant decimals = 8;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100000; // 0.00001 Ether
uint256 public tokensPerEth = 25000000e8;
uint public target0drop = 5100;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0xDAC3d5c543871C563f26eCdB5D3F3fD4F884841B ;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 8400000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 1100e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 211,687 | 11,986 |
f7982f5d7f0d122c209a9a1c44b743ec1a403f9aca1d942f35286ca602744199
| 22,755 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c0/c06a313b3ff81e91837dda6de04687ed55fc974e_Oracle.sol
| 4,642 | 16,626 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring "a" not being zero, but the
// benefit is lost if "b" is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn"t hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
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 Babylonian {
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;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract 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 Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, "Epoch: not started yet");
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), "Epoch: only operator allowed for pre-epoch");
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, "_period: out of range");
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there"s liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 313,752 | 11,987 |
f5fa71952826a7091dddbcc6011d2248d4935c39aa5700cf4ea05609d88922de
| 21,765 |
.sol
|
Solidity
| false |
456341132
|
Dev-Topaz/Destiny-BEP20
|
beb6dd5994c8285a5714ae3b665dd3d1a7efd053
|
Destiny.sol
| 2,590 | 10,024 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this; // silence state mutability warning without generating bytecode
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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) {
// 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;
}
function min(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a < b ? a : b;
}
function max(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a > b ? a : b;
}
}
contract SafeToken is Ownable {
address payable _safeManager;
constructor() {
_safeManager = payable(_msgSender());
}
function setSafeManager(address payable account) public onlyOwner {
_safeManager = account;
}
function withdraw(address addr, uint256 amount) external {
require(_msgSender() == _safeManager, "SafeToken: caller is not the manager");
IBEP20(addr).transfer(_safeManager, amount);
}
function withdrawBNB(uint256 amount) external {
require(_msgSender() == _safeManager, "SafeToken: caller is not the manager");
_safeManager.transfer(amount);
}
}
contract LockToken is Ownable {
mapping(address => bool) private _blackList;
modifier open(address account) {
require(!_blackList[account], "LockToken: caller is blacklisted");
_;
}
function includeToBlackList(address account) external onlyOwner {
_blackList[account] = true;
}
function excludeFromBlackList(address account) external onlyOwner {
_blackList[account] = false;
}
function isBlackListed(address account) external view returns(bool) {
return _blackList[account];
}
}
contract DestinyCoin is Context, Ownable, IBEP20, SafeToken, LockToken {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "MY DESTINY";
string private _symbol = "MD";
uint8 private _decimals = 18;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
constructor() {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function getOwner() external view override returns (address) {
return owner();
}
function name() external view override returns (string memory) {
return _name;
}
function symbol() external view override returns (string memory) {
return _symbol;
}
function decimals() external view override returns (uint8) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(amount));
return true;
}
function decreaseAllowance(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(amount, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) external onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) external onlyOwner returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function burnFrom(address from, uint256 amount) external onlyOwner returns (bool) {
_burnFrom(from, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal open(sender) {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "BEP20: transfer amount is zero");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
require(amount > 0, "BEP20: approve amount is zero");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, 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 _burnFrom(address account, uint256 amount) internal {
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
_burn(account, amount);
}
}
| 227,353 | 11,988 |
6571b2d1855519b5a977bd3a28241da5e014762c03f84d060df989ca17c3e04b
| 18,603 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xabdbbbd3fea294cbce25091f8fd1d7bc875060ff.sol
| 3,225 | 12,248 |
pragma solidity ^0.4.18;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function _burn(address _burner, uint256 _value) internal {
require(_value <= balances[_burner]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_burner] = balances[_burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(_burner, _value);
Transfer(_burner, address(0), _value);
}
}
contract DividendPayoutToken is BurnableToken, MintableToken {
// Dividends already claimed by investor
mapping(address => uint256) public dividendPayments;
// Total dividends claimed by all investors
uint256 public totalDividendPayments;
// invoke this function after each dividend payout
function increaseDividendPayments(address _investor, uint256 _amount) onlyOwner public {
dividendPayments[_investor] = dividendPayments[_investor].add(_amount);
totalDividendPayments = totalDividendPayments.add(_amount);
}
//When transfer tokens decrease dividendPayments for sender and increase for receiver
function transfer(address _to, uint256 _value) public returns (bool) {
// balance before transfer
uint256 oldBalanceFrom = balances[msg.sender];
// invoke super function with requires
bool isTransferred = super.transfer(_to, _value);
uint256 transferredClaims = dividendPayments[msg.sender].mul(_value).div(oldBalanceFrom);
dividendPayments[msg.sender] = dividendPayments[msg.sender].sub(transferredClaims);
dividendPayments[_to] = dividendPayments[_to].add(transferredClaims);
return isTransferred;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
// balance before transfer
uint256 oldBalanceFrom = balances[_from];
// invoke super function with requires
bool isTransferred = super.transferFrom(_from, _to, _value);
uint256 transferredClaims = dividendPayments[_from].mul(_value).div(oldBalanceFrom);
dividendPayments[_from] = dividendPayments[_from].sub(transferredClaims);
dividendPayments[_to] = dividendPayments[_to].add(transferredClaims);
return isTransferred;
}
function burn() public {
address burner = msg.sender;
// balance before burning tokens
uint256 oldBalance = balances[burner];
super._burn(burner, oldBalance);
uint256 burnedClaims = dividendPayments[burner];
dividendPayments[burner] = dividendPayments[burner].sub(burnedClaims);
totalDividendPayments = totalDividendPayments.sub(burnedClaims);
SaleInterface(owner).refund(burner);
}
}
contract RicoToken is DividendPayoutToken {
string public constant name = "Rico";
string public constant symbol = "Rico";
uint8 public constant decimals = 18;
}
// Interface for PreSale and CrowdSale contracts with refund function
contract SaleInterface {
function refund(address _to) public;
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract PreSale is Ownable, ReentrancyGuard {
using SafeMath for uint256;
// The token being sold
RicoToken public token;
address tokenContractAddress;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// Address where funds are transferred after success end of PreSale
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
uint256 public minimumInvest; // in wei
uint256 public softCap; // in wei
uint256 public hardCap; // in wei
// investors => amount of money
mapping(address => uint) public balances;
// Amount of wei raised
uint256 public weiRaised;
// PreSale bonus in percent
uint256 bonusPercent;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PreSale(address _token) public
{
startTime = 1525251600;
endTime = startTime + 60 minutes;
wallet = 0x2c9660f30B65dbBfd6540d252f6Fa07B5854a40f;
token = RicoToken(_token);
tokenContractAddress = _token;
// minimumInvest in wei
minimumInvest = 1000000000000;
// 1 token for approximately 0.00015 eth
rate = 1000;
softCap = 150 * 0.000001 ether;
hardCap = 1500 * 0.000001 ether;
bonusPercent = 50;
}
// @return true if the transaction can buy tokens
modifier saleIsOn() {
bool withinPeriod = now >= startTime && now <= endTime;
require(withinPeriod);
_;
}
modifier isUnderHardCap() {
require(weiRaised < hardCap);
_;
}
modifier refundAllowed() {
require(weiRaised < softCap && now > endTime);
_;
}
// @return true if PreSale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
// Refund ether to the investors (invoke from only token)
function refund(address _to) public refundAllowed {
require(msg.sender == tokenContractAddress);
uint256 valueToReturn = balances[_to];
// update states
balances[_to] = 0;
weiRaised = weiRaised.sub(valueToReturn);
_to.transfer(valueToReturn);
}
// Get amount of tokens
// @param value weis paid for tokens
function getTokenAmount(uint256 _value) internal view returns (uint256) {
return _value.mul(rate);
}
// Send weis to the wallet
function forwardFunds(uint256 _value) internal {
wallet.transfer(_value);
}
// Success finish of PreSale
function finishPreSale() public onlyOwner {
require(weiRaised >= softCap);
require(weiRaised >= hardCap || now > endTime);
if (now < endTime) {
endTime = now;
}
forwardFunds(this.balance);
token.transferOwnership(owner);
}
// Change owner of token after end of PreSale if Soft Cap has not raised
function changeTokenOwner() public onlyOwner {
require(now > endTime && weiRaised < softCap);
token.transferOwnership(owner);
}
// low level token purchase function
function buyTokens(address _beneficiary) saleIsOn isUnderHardCap nonReentrant public payable {
require(_beneficiary != address(0));
require(msg.value >= minimumInvest);
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
tokens = tokens.add(tokens.mul(bonusPercent).div(100));
token.mint(_beneficiary, tokens);
// update states
weiRaised = weiRaised.add(weiAmount);
balances[_beneficiary] = balances[_beneficiary].add(weiAmount);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
}
function() external payable {
buyTokens(msg.sender);
}
}
| 147,421 | 11,989 |
0cfeb9b58ca85ad5c3d74e1a5b4a92cf61bf6d92a0682aa818c6d9135906617e
| 18,141 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFePveugPwDKo49o5p797ZL1vJ7MHRgu5j_BITEL.sol
| 4,117 | 15,136 |
//SourceUnit: bitel.sol
pragma solidity ^0.5.8;
interface ITRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeTRC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function callOptionalReturn(ITRC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeTRC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeTRC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed");
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract BITEL {
using SafeMath for uint;
using SafeTRC20 for ITRC20;
ITRC20 public token;
uint256 constant public DEPOSITS_MAX = 100;
uint256 constant public BASE_PERCENT = 100;
uint256[] public REFERRAL_PERCENTS = [500, 200, 100, 50, 50];
uint256 constant public MARKETING_FEE = 600;
uint256 constant public ADMIN_FEE = 400;
uint256 constant public MAX_CONTRACT_PERCENT = 500;
uint256 constant public MAX_HOLD_PERCENT = 1000;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public CONTRACT_BALANCE_STEP = 500000 * (10 ** 6);
uint256 constant public TIME_STEP = 1 days;
uint256 public totalDeposits;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public contractPercent;
address public marketingAddress;
address public adminAddress;
struct Deposit {
uint128 amount;
uint128 withdrawn;
uint128 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint16 rbackPercent;
uint128 bonus;
uint24[5] refs;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event RefBack(address indexed referrer, address indexed referral, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address marketingAddr,address adminAddr, ITRC20 tokenAddr) public {
require(!isContract(marketingAddr));
token = tokenAddr;
marketingAddress = marketingAddr;
adminAddress=adminAddr;
contractPercent = getContractBalanceRate();
}
function invest(uint256 depAmount, address referrer) public {
require(!isContract(msg.sender) && msg.sender == tx.origin);
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
token.safeTransferFrom(msg.sender, address(this), depAmount);
uint256 marketingFee = depAmount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint256 adminFee = depAmount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
token.safeTransfer(marketingAddress, marketingFee);
token.safeTransfer(adminAddress, adminFee);
emit FeePayed(msg.sender, marketingFee);
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
uint256 refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = depAmount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (i == 0 && users[upline].rbackPercent > 0) {
refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER);
token.safeTransfer(msg.sender, refbackAmount);
emit RefBack(upline, msg.sender, refbackAmount);
amount = amount.sub(refbackAmount);
}
if (amount > 0) {
token.safeTransfer(upline, amount);
users[upline].bonus = uint128(uint(users[upline].bonus).add(amount));
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint128(depAmount), 0, uint128(refbackAmount), uint32(block.timestamp)));
totalInvested = totalInvested.add(depAmount);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint256 contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, depAmount);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint128(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = token.balanceOf(address(this));
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp);
token.safeTransfer(msg.sender, totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setRefback(uint16 rbackPercent) public {
require(rbackPercent <= 10000);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
user.rbackPercent = rbackPercent;
}
}
function getContractBalance() public view returns (uint) {
return token.balanceOf(address(this));
}
function getContractBalanceRate() internal view returns (uint) {
uint256 contractBalance = token.balanceOf(address(this));
uint256 contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(5));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 amount = user.bonus;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn)).add(uint(user.deposits[i].refback));
}
return amount;
}
function getUserDeposits(address userAddress, uint256 last, uint256 first) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
User storage user = users[userAddress];
uint256 count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint256[] memory amount = new uint256[](count);
uint256[] memory withdrawn = new uint256[](count);
uint256[] memory refback = new uint256[](count);
uint256[] memory start = new uint256[](count);
uint256 index = 0;
for (uint256 i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, getContractBalance(), contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint256 userPerc = getUserPercentRate(userAddress);
uint256 userAvailable = getUserAvailable(userAddress);
uint256 userDepsTotal = getUserTotalDeposits(userAddress);
uint256 userDeposits = getUserAmountOfDeposits(userAddress);
uint256 userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint16, uint16, uint128, uint24[5] memory) {
User storage user = users[userAddress];
return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 296,492 | 11,990 |
ba4810402b89e7d0e5fab31f5e8cdcb966373a1ea45641efdfa897d6365570da
| 13,122 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xedbe509e65f7425016265a049941311497c0099c.sol
| 3,075 | 12,189 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier notOwner() {
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 Resume();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function resume() onlyOwner whenPaused public {
paused = false;
emit Resume();
}
}
contract LuckyYouTokenInterface {
function airDrop(address _to, uint256 _value) public returns (bool);
function balanceOf(address who) public view returns (uint256);
}
contract LuckyYouContract is Pausable {
using SafeMath for uint256;
LuckyYouTokenInterface public luckyYouToken = LuckyYouTokenInterface(0x6D7efEB3DF42e6075fa7Cf04E278d2D69e26a623); //LKY token address
bool public airDrop = true;// weather airdrop LKY tokens to participants or not,owner can set it to true or false;
//set airDrop flag
function setAirDrop(bool _airDrop) public onlyOwner {
airDrop = _airDrop;
}
uint public baseTokenGetRate = 100;
// set token get rate
function setBaseTokenGetRate(uint _baseTokenGetRate) public onlyOwner {
baseTokenGetRate = _baseTokenGetRate;
}
//if the number of participants less than minParticipants,game will not be fired.owner can set it
uint public minParticipants = 50;
function setMinParticipants(uint _minParticipants) public onlyOwner {
minParticipants = _minParticipants;
}
//base price ,owner can set it
uint public basePrice = 0.01 ether;
function setBasePrice(uint _basePrice) public onlyOwner {
basePrice = _basePrice;
}
uint[5] public times = [1, 5, 5 * 5, 5 * 5 * 5, 5 * 5 * 5 * 5];//1x=0.01 ether;5x=0.05 ether; 5*5x=0.25 ether; 5*5*5x=1.25 ether; 5*5*5*5x=6.25 ether;
//at first only enable 1x(0.02ether) ,enable others proper time in future
bool[5] public timesEnabled = [true, false, false, false, false];
uint[5] public currentCounter = [1, 1, 1, 1, 1];
mapping(address => uint[5]) public participatedCounter;
mapping(uint8 => address[]) private participants;
//todo
mapping(uint8 => uint256) public participantsCount;
mapping(uint8 => uint256) public fundShareLastRound;
mapping(uint8 => uint256) public fundCurrentRound;
mapping(uint8 => uint256) public fundShareRemainLastRound;
mapping(uint8 => uint256) public fundShareParticipantsTotalTokensLastRound;
mapping(uint8 => uint256) public fundShareParticipantsTotalTokensCurrentRound;
mapping(uint8 => bytes32) private participantsHashes;
mapping(uint8 => uint8) private lastFiredStep;
mapping(uint8 => address) public lastWinner;
mapping(uint8 => address) public lastFiredWinner;
mapping(uint8 => uint256) public lastWinnerReward;
mapping(uint8 => uint256) public lastFiredWinnerReward;
mapping(uint8 => uint256) public lastFiredFund;
mapping(address => uint256) public whitelist;
uint256 public notInWhitelistAllow = 1;
bytes32 private commonHash = 0x1000;
uint256 public randomNumberIncome = 0;
event Winner1(address value, uint times, uint counter, uint256 reward);
event Winner2(address value, uint times, uint counter, uint256 reward);
function setNotInWhitelistAllow(uint _value) public onlyOwner
{
notInWhitelistAllow = _value;
}
function setWhitelist(uint _value,address [] _addresses) public onlyOwner
{
uint256 count = _addresses.length;
for (uint256 i = 0; i < count; i++) {
whitelist[_addresses [i]] = _value;
}
}
function setTimesEnabled(uint8 _timesIndex, bool _enabled) public onlyOwner
{
require(_timesIndex < timesEnabled.length);
timesEnabled[_timesIndex] = _enabled;
}
function() public payable whenNotPaused {
if(whitelist[msg.sender] | notInWhitelistAllow > 0)
{
uint8 _times_length = uint8(times.length);
uint8 _times = _times_length + 1;
for (uint32 i = 0; i < _times_length; i++)
{
if (timesEnabled[i])
{
if (times[i] * basePrice == msg.value) {
_times = uint8(i);
break;
}
}
}
if (_times > _times_length) {
revert();
}
else
{
if (participatedCounter[msg.sender][_times] < currentCounter[_times])
{
participatedCounter[msg.sender][_times] = currentCounter[_times];
if (airDrop)
{
uint256 _value = baseTokenGetRate * 10 ** 18 * times[_times];
uint256 _plus_value = uint256(keccak256(now, msg.sender)) % _value;
luckyYouToken.airDrop(msg.sender, _value + _plus_value);
}
uint256 senderBalance = luckyYouToken.balanceOf(msg.sender);
if (lastFiredStep[_times] > 0)
{
issueLottery(_times);
fundShareParticipantsTotalTokensCurrentRound[_times] += senderBalance;
senderBalance = senderBalance.mul(2);
} else
{
fundShareParticipantsTotalTokensCurrentRound[_times] += senderBalance;
}
if (participantsCount[_times] == participants[_times].length)
{
participants[_times].length += 1;
}
participants[_times][participantsCount[_times]++] = msg.sender;
participantsHashes[_times] = keccak256(msg.sender, uint256(commonHash));
commonHash = keccak256(senderBalance,commonHash);
fundCurrentRound[_times] += times[_times] * basePrice;
//share last round fund
if (fundShareRemainLastRound[_times] > 0)
{
uint256 _shareFund = fundShareLastRound[_times].mul(senderBalance).div(fundShareParticipantsTotalTokensLastRound[_times]);
if(_shareFund > 0)
{
if (_shareFund <= fundShareRemainLastRound[_times]) {
fundShareRemainLastRound[_times] -= _shareFund;
msg.sender.transfer(_shareFund);
} else {
uint256 _fundShareRemain = fundShareRemainLastRound[_times];
fundShareRemainLastRound[_times] = 0;
msg.sender.transfer(_fundShareRemain);
}
}
}
if (participantsCount[_times] > minParticipants)
{
if (uint256(keccak256(now, msg.sender, commonHash)) % (minParticipants * minParticipants) < minParticipants)
{
fireLottery(_times);
}
}
} else
{
revert();
}
}
}else{
revert();
}
}
function issueLottery(uint8 _times) private {
uint256 _totalFundRate = lastFiredFund[_times].div(100);
if (lastFiredStep[_times] == 1) {
fundShareLastRound[_times] = _totalFundRate.mul(30) + fundShareRemainLastRound[_times];
if (randomNumberIncome > 0)
{
if (_times == (times.length - 1) || timesEnabled[_times + 1] == false)
{
fundShareLastRound[_times] += randomNumberIncome;
randomNumberIncome = 0;
}
}
fundShareRemainLastRound[_times] = fundShareLastRound[_times];
fundShareParticipantsTotalTokensLastRound[_times] = fundShareParticipantsTotalTokensCurrentRound[_times];
fundShareParticipantsTotalTokensCurrentRound[_times] = 0;
if(fundShareParticipantsTotalTokensLastRound[_times] == 0)
{
fundShareParticipantsTotalTokensLastRound[_times] = 10000 * 10 ** 18;
}
lastFiredStep[_times]++;
} else if (lastFiredStep[_times] == 2) {
lastWinner[_times].transfer(_totalFundRate.mul(65));
lastFiredStep[_times]++;
lastWinnerReward[_times] = _totalFundRate.mul(65);
emit Winner1(lastWinner[_times], _times, currentCounter[_times] - 1, _totalFundRate.mul(65));
} else if (lastFiredStep[_times] == 3) {
if (lastFiredFund[_times] > (_totalFundRate.mul(30) + _totalFundRate.mul(4) + _totalFundRate.mul(65)))
{
owner.transfer(lastFiredFund[_times] - _totalFundRate.mul(30) - _totalFundRate.mul(4) - _totalFundRate.mul(65));
}
lastFiredStep[_times] = 0;
}
}
function fireLottery(uint8 _times) private {
lastFiredFund[_times] = fundCurrentRound[_times];
fundCurrentRound[_times] = 0;
lastWinner[_times] = participants[_times][uint256(participantsHashes[_times]) % participantsCount[_times]];
participantsCount[_times] = 0;
uint256 winner2Reward = lastFiredFund[_times].div(100).mul(4);
msg.sender.transfer(winner2Reward);
lastFiredWinner[_times] = msg.sender;
lastFiredWinnerReward[_times] = winner2Reward;
emit Winner2(msg.sender, _times, currentCounter[_times], winner2Reward);
lastFiredStep[_times] = 1;
currentCounter[_times]++;
}
function _getRandomNumber(uint _round) view private returns (uint256){
return uint256(keccak256(participantsHashes[0],
participantsHashes[1],
participantsHashes[2],
participantsHashes[3],
participantsHashes[4],
msg.sender)) % _round;
}
function getRandomNumber(uint _round) public payable returns (uint256){
uint256 tokenBalance = luckyYouToken.balanceOf(msg.sender);
if (tokenBalance >= 100000 * 10 ** 18)
{
return _getRandomNumber(_round);
} else if (msg.value >= basePrice) {
randomNumberIncome += msg.value;
return _getRandomNumber(_round);
} else {
revert();
return 0;
}
}
//in case some bugs
function kill() public {//for test
if (msg.sender == owner)
{
selfdestruct(owner);
}
}
}
| 223,248 | 11,991 |
b46e9912d06823a1ea8f326fec47af4c62c9ad5646f8217265173f2697fc46ad
| 28,260 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0xba2184520a1cc49a6159c57e61e1844e085615b6-HGT-HelloGold.sol
| 4,884 | 17,166 |
pragma solidity ^0.4.11;
contract DoNotDeployThisGetTheRightOneCosParityPutsThisOnTop {
uint256 nothing;
function DoNotDeployThisGetTheRightOneCosParityPutsThisOnTop() {
nothing = 27;
}
}
/
modifier whenNotPaused() {
require (!paused);
_;
}
modifier whenPaused {
require (paused) ;
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
/
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) returns (bool success){
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
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) {
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 GBT {
function parentChange(address,uint);
function parentFees(address);
function setHGT(address _hgt);
}
/
mapping (address => Balance) public balances;
mapping (address => mapping (address => uint)) allowed;
function update(address where) internal {
uint256 pos;
uint256 fees;
uint256 val;
(val,fees,pos) = updatedBalance(where);
balances[where].nextAllocationIndex = pos;
balances[where].amount = val;
balances[where].lastUpdated = now;
}
function updatedBalance(address where) constant public returns (uint val, uint fees, uint pos) {
uint256 c_val;
uint256 c_fees;
uint256 c_amount;
(val, fees) = calcFees(balances[where].lastUpdated,now,balances[where].amount);
pos = balances[where].nextAllocationIndex;
if ((pos < currentAllocations.length) && (balances[where].allocationShare != 0)) {
c_amount = currentAllocations[balances[where].nextAllocationIndex].amount * balances[where].allocationShare / allocationPool;
(c_val,c_fees) = calcFees(currentAllocations[balances[where].nextAllocationIndex].date,now,c_amount);
}
val += c_val;
fees += c_fees;
pos = currentAllocations.length;
}
function balanceOf(address where) constant returns (uint256 val) {
uint256 fees;
uint256 pos;
(val,fees,pos) = updatedBalance(where);
return ;
}
event Allocation(uint256 amount, uint256 date);
event FeeOnAllocation(uint256 fees, uint256 date);
event PartComplete();
event StillToGo(uint numLeft);
uint256 public partPos;
uint256 public partFees;
uint256 partL;
allocation[] public partAllocations;
function partAllocationLength() constant returns (uint) {
return partAllocations.length;
}
function addAllocationPartOne(uint newAllocation,uint numSteps) onlyOwner{
uint256 thisAllocation = newAllocation;
require(totAllocation < maxAllocation); // cannot allocate more than this;
if (currentAllocations.length > partAllocations.length) {
partAllocations = currentAllocations;
}
if (totAllocation + thisAllocation > maxAllocation) {
thisAllocation = maxAllocation - totAllocation;
log0("max alloc reached");
}
totAllocation += thisAllocation;
Allocation(thisAllocation,now);
allocation memory newDiv;
newDiv.amount = thisAllocation;
newDiv.date = now;
// store into history
allocationsOverTime.push(newDiv);
// add this record to the end of currentAllocations
partL = partAllocations.push(newDiv);
// update all other records with calcs from last record
if (partAllocations.length < 2) { // no fees to consider
PartComplete();
currentAllocations = partAllocations;
FeeOnAllocation(0,now);
return;
}
//
// The only fees that need to be collected are the fees on location zero.
// Since they are the last calculated = they come out with the break
//
for (partPos = partAllocations.length - 2; partPos >= 0; partPos--){
(partAllocations[partPos].amount,partFees) = calcFees(partAllocations[partPos].date,now,partAllocations[partPos].amount);
partAllocations[partPos].amount += partAllocations[partL - 1].amount;
partAllocations[partPos].date = now;
if ((partPos == 0) || (partPos == partAllocations.length-numSteps)){
break;
}
}
if (partPos != 0) {
StillToGo(partPos);
return; // not done yet
}
PartComplete();
FeeOnAllocation(partFees,now);
currentAllocations = partAllocations;
}
function addAllocationPartTwo(uint numSteps) onlyOwner {
require(numSteps > 0);
require(partPos > 0);
for (uint i = 0; i < numSteps; i++){
partPos--;
(partAllocations[partPos].amount,partFees) = calcFees(partAllocations[partPos].date,now,partAllocations[partPos].amount);
partAllocations[partPos].amount += partAllocations[partL - 1].amount;
partAllocations[partPos].date = now;
if (partPos == 0) {
break;
}
}
if (partPos != 0) {
StillToGo(partPos);
return; // not done yet
}
PartComplete();
FeeOnAllocation(partFees,now);
currentAllocations = partAllocations;
}
function setHGT(address _hgt) onlyOwner {
HGT = _hgt;
}
function parentFees(address where) whenNotPaused {
require(msg.sender == HGT);
update(where);
}
function parentChange(address where, uint newValue) whenNotPaused { // called when HGT balance changes
require(msg.sender == HGT);
balances[where].allocationShare = newValue;
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool ok) {
update(msg.sender); // Do this to ensure sender has enough funds.
update(_to);
balances[msg.sender].amount = safeSub(balances[msg.sender].amount, _value);
balances[_to].amount = safeAdd(balances[_to].amount, _value);
Transfer(msg.sender, _to, _value); //Notify anyone listening that this transfer took place
return true;
}
function transferFrom(address _from, address _to, uint _value) whenNotPaused returns (bool success) {
var _allowance = allowed[_from][msg.sender];
update(_from); // Do this to ensure sender has enough funds.
update(_to);
balances[_to].amount = safeAdd(balances[_to].amount, _value);
balances[_from].amount = safeSub(balances[_from].amount, _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) whenNotPaused returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
// Minting Functions
address public authorisedMinter;
function setMinter(address minter) onlyOwner {
authorisedMinter = minter;
}
function mintTokens(address destination, uint256 amount) {
require(msg.sender == authorisedMinter);
update(destination);
balances[destination].amount = safeAdd(balances[destination].amount, amount);
balances[destination].lastUpdated = now;
balances[destination].nextAllocationIndex = currentAllocations.length;
TokenMinted(destination,amount);
}
function burnTokens(address source, uint256 amount) {
require(msg.sender == authorisedMinter);
update(source);
balances[source].amount = safeSub(balances[source].amount,amount);
balances[source].lastUpdated = now;
balances[source].nextAllocationIndex = currentAllocations.length;
TokenBurned(source,amount);
}
}
/
mapping (address => csAction) public permissions;
mapping (address => uint256) public deposits;
modifier MustBeEnabled(address x) {
require (!permissions[x].blocked) ;
require (permissions[x].passedKYC) ;
_;
}
function HelloGoldSale(address _cs, address _hgt, address _multiSig, address _reserve) {
cs = _cs;
token = HelloGoldToken(_hgt);
multiSig = _multiSig;
HGT_Reserve = _reserve;
}
// We only expect to use this to set/reset the start of the contract under exceptional circumstances
function setStart(uint256 when_) onlyOwner {
startDate = when_;
endDate = when_ + tranchePeriod;
}
modifier MustBeCs() {
require (msg.sender == cs) ;
_;
}
// 1 ether = N HGT tokens
uint256[5] public hgtRates = [1248900000000,1196900000000,1144800000000,1092800000000,1040700000000];
function approve(address user) MustBeCs {
permissions[user].passedKYC = true;
}
function block(address user) MustBeCs {
permissions[user].blocked = true;
}
function unblock(address user) MustBeCs {
permissions[user].blocked = false;
}
function newCs(address newCs) onlyOwner {
cs = newCs;
}
function setPeriod(uint256 period_) onlyOwner {
require (!funding()) ;
tranchePeriod = period_;
endDate = startDate + tranchePeriod;
if (endDate < now + tranchePeriod) {
endDate = now + tranchePeriod;
}
}
function when() constant returns (uint256) {
return now;
}
function funding() constant returns (bool) {
if (paused) return false; // frozen
if (now < startDate) return false; // too early
if (now > endDate) return false; // too late
if (coinsRemaining == 0) return false; // no more coins
if (tierNo >= numTiers) return false; // passed end of top tier. Tiers start at zero
return true;
}
function success() constant returns (bool succeeded) {
if (coinsRemaining == 0) return true;
bool complete = (now > endDate) ;
bool didOK = (coinsRemaining <= (MaxCoinsR1 - minimumCap)); // not even 40M Gone?? Aargh.
succeeded = (complete && didOK) ; // (out of steam but enough sold)
return ;
}
function failed() constant returns (bool didNotSucceed) {
bool complete = (now > endDate);
bool didBad = (coinsRemaining > (MaxCoinsR1 - minimumCap));
didNotSucceed = (complete && didBad);
return;
}
function () payable MustBeEnabled(msg.sender) whenNotPaused {
createTokens(msg.sender,msg.value);
}
function linkCoin(address coin) onlyOwner {
token = HelloGoldToken(coin);
}
function coinAddress() constant returns (address) {
return address(token);
}
// hgtRates in whole tokens per ETH
// max individual contribution in whole ETH
function setHgtRates(uint256 p0,uint256 p1,uint256 p2,uint256 p3,uint256 p4, uint256 _max) onlyOwner {
require (now < startDate) ;
hgtRates[0] = p0 * 10**8;
hgtRates[1] = p1 * 10**8;
hgtRates[2] = p2 * 10**8;
hgtRates[3] = p3 * 10**8;
hgtRates[4] = p4 * 10**8;
personalMax = _max * 1 ether; // max ETH per person
}
event Purchase(address indexed buyer, uint256 level,uint256 value, uint256 tokens);
event Reduction(string msg, address indexed buyer, uint256 wanted, uint256 allocated);
function createTokens(address recipient, uint256 value) private {
uint256 totalTokens;
uint256 hgtRate;
require (funding()) ;
require (value > 1 finney) ;
require (deposits[recipient] < personalMax);
uint256 maxRefund = 0;
if ((deposits[msg.sender] + value) > personalMax) {
maxRefund = deposits[msg.sender] + value - personalMax;
value -= maxRefund;
log0("maximum funds exceeded");
}
uint256 val = value;
ethRaised = safeAdd(ethRaised,value);
if (deposits[recipient] == 0) contributors++;
do {
hgtRate = hgtRates[tierNo]; // hgtRate must include the 10^8
uint tokens = safeMul(val, hgtRate); // (val in eth * 10^18) * #tokens per eth
tokens = safeDiv(tokens, 1 ether); // val is in ether, msg.value is in wei
if (tokens <= coinsLeftInTier) {
uint256 actualTokens = tokens;
uint refund = 0;
if (tokens > coinsRemaining) { //can't sell desired # tokens
Reduction("in tier",recipient,tokens,coinsRemaining);
actualTokens = coinsRemaining;
refund = safeSub(tokens, coinsRemaining); // refund amount in tokens
refund = safeDiv(refund*1 ether,hgtRate); // refund amount in ETH
// need a refund mechanism here too
coinsRemaining = 0;
val = safeSub(val,refund);
} else {
coinsRemaining = safeSub(coinsRemaining, actualTokens);
}
purchasedCoins = safeAdd(purchasedCoins, actualTokens);
totalTokens = safeAdd(totalTokens,actualTokens);
require (token.transferFrom(HGT_Reserve, recipient,totalTokens)) ;
Purchase(recipient,tierNo,val,actualTokens); // event
deposits[recipient] = safeAdd(deposits[recipient],val); // in case of refund - could pull off etherscan
refund += maxRefund;
if (refund > 0) {
ethRaised = safeSub(ethRaised,refund);
recipient.transfer(refund);
}
if (coinsRemaining <= (MaxCoinsR1 - minimumCap)){ // has passed success criteria
if (!multiSig.send(this.balance)) { // send funds to HGF
log0("cannot forward funds to owner");
}
}
coinsLeftInTier = safeSub(coinsLeftInTier,actualTokens);
if ((coinsLeftInTier == 0) && (coinsRemaining != 0)) { // exact sell out of non final tier
coinsLeftInTier = coinsPerTier;
tierNo++;
endDate = now + tranchePeriod;
}
return;
}
// check that coinsLeftInTier >= coinsRemaining
uint256 coins2buy = min256(coinsLeftInTier , coinsRemaining);
endDate = safeAdd(now, tranchePeriod);
// Have bumped levels - need to modify end date here
purchasedCoins = safeAdd(purchasedCoins, coins2buy); // give all coins remaining in this tier
totalTokens = safeAdd(totalTokens,coins2buy);
coinsRemaining = safeSub(coinsRemaining,coins2buy);
uint weiCoinsLeftInThisTier = safeMul(coins2buy,1 ether);
uint costOfTheseCoins = safeDiv(weiCoinsLeftInThisTier, hgtRate); // how much did that cost?
Purchase(recipient, tierNo,costOfTheseCoins,coins2buy); // event
deposits[recipient] = safeAdd(deposits[recipient],costOfTheseCoins);
val = safeSub(val,costOfTheseCoins);
tierNo = tierNo + 1;
coinsLeftInTier = coinsPerTier;
} while ((val > 0) && funding());
// escaped because we passed the end of the universe.....
// so give them their tokens
require (token.transferFrom(HGT_Reserve, recipient,totalTokens)) ;
if ((val > 0) || (maxRefund > 0)){
Reduction("finished crowdsale, returning ",recipient,value,totalTokens);
// return the remainder !
recipient.transfer(val+maxRefund); // if you can't return the balance, abort whole process
}
if (!multiSig.send(this.balance)) {
ethRaised = safeSub(ethRaised,this.balance);
log0("cannot send at tier jump");
}
}
function allocatedTokens(address grantee, uint256 numTokens) onlyOwner {
require (now < startDate) ;
if (numTokens < coinsRemaining) {
coinsRemaining = safeSub(coinsRemaining, numTokens);
} else {
numTokens = coinsRemaining;
coinsRemaining = 0;
}
preallocCoins = safeAdd(preallocCoins,numTokens);
require (token.transferFrom(HGT_Reserve,grantee,numTokens));
}
function withdraw() { // it failed. Come and get your ether.
if (failed()) {
if (deposits[msg.sender] > 0) {
uint256 val = deposits[msg.sender];
deposits[msg.sender] = 0;
msg.sender.transfer(val);
}
}
}
function complete() onlyOwner { // this should not have to be called. Extreme measures.
if (success()) {
uint256 val = this.balance;
if (val > 0) {
if (!multiSig.send(val)) {
log0("cannot withdraw");
} else {
log0("funds withdrawn");
}
} else {
log0("nothing to withdraw");
}
}
}
}
| 247,405 | 11,992 |
d6a4ed042a145dcc80f69802b0a177523a4926bf158168d3dcb6bf22a76d6b56
| 22,374 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7970_9758_0x29e240cfd7946ba20895a7a02edb25c210f9f324.sol
| 5,554 | 21,832 |
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 Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _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 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 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;
}
}
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;
function want(address) external view returns (address);
}
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);
function getUserReserveData(address _reserve, address _user)
external
view
returns (uint currentATokenBalance,
uint currentBorrowBalance,
uint principalBorrowBalance,
uint borrowRateMode,
uint borrowRate,
uint liquidityRate,
uint originationFee,
uint variableBorrowIndex,
uint lastUpdateTimestamp,
bool usageAsCollateralEnabled);
}
interface AaveToken {
function underlyingAssetAddress() external view 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 yDelegatedVault is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public token;
address public governance;
address public controller;
uint public insurance;
uint public healthFactor = 4;
uint public ltv = 65;
uint public max = 100;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
constructor (address _token, address _controller) public ERC20Detailed(string(abi.encodePacked("yearn ", ERC20Detailed(_token).name())),
string(abi.encodePacked("y", ERC20Detailed(_token).symbol())),
ERC20Detailed(_token).decimals()) {
token = IERC20(_token);
governance = msg.sender;
controller = _controller;
}
function debt() public view returns (uint) {
address _reserve = Controller(controller).want(address(this));
(,uint currentBorrowBalance,,,,,,,,) = Aave(getAave()).getUserReserveData(_reserve, address(this));
return currentBorrowBalance;
}
function credit() public view returns (uint) {
return Controller(controller).balanceOf(address(this));
}
// % of tokens locked and cannot be withdrawn per user
// this is impermanent locked, unless the debt out accrues the strategy
function locked() public view returns (uint) {
return credit().mul(1e18).div(debt());
}
function debtShare(address _lp) public view returns (uint) {
return debt().mul(balanceOf(_lp)).mul(totalSupply());
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore();
}
function setHealthFactor(uint _hf) external {
require(msg.sender == governance, "!governance");
healthFactor = _hf;
}
function activate() public {
Aave(getAave()).setUserUseReserveAsCollateral(underlying(), true);
}
function repay(address reserve, uint amount) public {
// 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))));
}
function repayAll() public {
address _reserve = reserve();
uint _amount = IERC20(_reserve).balanceOf(address(this));
repay(_reserve, _amount);
}
// Used to swap any borrowed reserve over the debt limit to liquidate to 'token'
function harvest(address reserve, uint amount) external {
require(msg.sender == controller, "!controller");
require(reserve != address(token), "token");
IERC20(reserve).safeTransfer(controller, amount);
}
// Ignore insurance fund for balance calculations
function balance() public view returns (uint) {
return token.balanceOf(address(this)).sub(insurance);
}
function setController(address _controller) external {
require(msg.sender == governance, "!governance");
controller = _controller;
}
function getAaveOracle() public view returns (address) {
return LendingPoolAddressesProvider(aave).getPriceOracle();
}
function getReservePriceETH(address reserve) public view returns (uint) {
return Oracle(getAaveOracle()).getAssetPrice(reserve);
}
function shouldRebalance() external view returns (bool) {
return (over() > 0);
}
function over() public view returns (uint) {
over(0);
}
function getUnderlyingPriceETH(uint _amount) public view returns (uint) {
_amount = _amount.mul(getUnderlyingPrice()).div(uint(10)**ERC20Detailed(address(token)).decimals()); // Calculate the amount we are withdrawing in ETH
return _amount.mul(ltv).div(max).div(healthFactor);
}
function over(uint _amount) public view returns (uint) {
address _reserve = reserve();
uint _eth = getUnderlyingPriceETH(_amount);
(uint _maxSafeETH,uint _totalBorrowsETH,) = maxSafeETH();
_maxSafeETH = _maxSafeETH.mul(105).div(100); // 5% buffer so we don't go into a earn/rebalance loop
if (_eth > _maxSafeETH) {
_maxSafeETH = 0;
} else {
_maxSafeETH = _maxSafeETH.sub(_eth); // Add the ETH we are withdrawing
}
if (_maxSafeETH < _totalBorrowsETH) {
uint _over = _totalBorrowsETH.mul(_totalBorrowsETH.sub(_maxSafeETH)).div(_totalBorrowsETH);
_over = _over.mul(uint(10)**ERC20Detailed(_reserve).decimals()).div(getReservePrice());
return _over;
} else {
return 0;
}
}
function _rebalance(uint _amount) internal {
uint _over = over(_amount);
if (_over > 0) {
if (_over > credit()) {
_over = credit();
}
if (_over > 0) {
Controller(controller).withdraw(address(this), _over);
repayAll();
}
}
}
function rebalance() external {
_rebalance(0);
}
function claimInsurance() external {
require(msg.sender == controller, "!controller");
token.safeTransfer(controller, insurance);
insurance = 0;
}
function maxSafeETH() public view returns (uint maxBorrowsETH, uint totalBorrowsETH, uint availableBorrowsETH) {
(,,uint _totalBorrowsETH,,uint _availableBorrowsETH,,,) = Aave(getAave()).getUserAccountData(address(this));
uint _maxBorrowETH = (_totalBorrowsETH.add(_availableBorrowsETH));
return (_maxBorrowETH.div(healthFactor), _totalBorrowsETH, _availableBorrowsETH);
}
function shouldBorrow() external view returns (bool) {
return (availableToBorrowReserve() > 0);
}
function availableToBorrowETH() public view returns (uint) {
(uint _maxSafeETH,uint _totalBorrowsETH, uint _availableBorrowsETH) = maxSafeETH();
_maxSafeETH = _maxSafeETH.mul(95).div(100); // 5% buffer so we don't go into a earn/rebalance loop
if (_maxSafeETH > _totalBorrowsETH) {
return _availableBorrowsETH.mul(_maxSafeETH.sub(_totalBorrowsETH)).div(_availableBorrowsETH);
} else {
return 0;
}
}
function availableToBorrowReserve() public view returns (uint) {
address _reserve = reserve();
uint _available = availableToBorrowETH();
if (_available > 0) {
return _available.mul(uint(10)**ERC20Detailed(_reserve).decimals()).div(getReservePrice());
} else {
return 0;
}
}
function getReservePrice() public view returns (uint) {
return getReservePriceETH(reserve());
}
function getUnderlyingPrice() public view returns (uint) {
return getReservePriceETH(underlying());
}
function earn() external {
address _reserve = reserve();
uint _borrow = availableToBorrowReserve();
if (_borrow > 0) {
Aave(getAave()).borrow(_reserve, _borrow, 2, 7);
}
//rebalance here
uint _balance = IERC20(_reserve).balanceOf(address(this));
if (_balance > 0) {
IERC20(_reserve).safeTransfer(controller, _balance);
Controller(controller).earn(address(this), _balance);
}
}
function depositAll() external {
deposit(token.balanceOf(msg.sender));
}
function deposit(uint _amount) public {
uint _pool = balance();
token.safeTransferFrom(msg.sender, address(this), _amount);
// 0.5% of deposits go into an insurance fund incase of negative profits to protect withdrawals
// At a 4 health factor, this is a -2% position
uint _insurance = _amount.mul(50).div(10000);
_amount = _amount.sub(_insurance);
insurance = insurance.add(_insurance);
//Controller can claim insurance to liquidate to cover interest
uint shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function reserve() public view returns (address) {
return Controller(controller).want(address(this));
}
function underlying() public view returns (address) {
return AaveToken(address(token)).underlyingAssetAddress();
}
function withdrawAll() public {
withdraw(balanceOf(msg.sender));
}
// Calculates in impermanent lock due to debt
function maxWithdrawal(address account) public view returns (uint) {
uint _balance = balanceOf(account);
uint _safeWithdraw = _balance.mul(locked()).div(1e18);
if (_safeWithdraw > _balance) {
return _balance;
} else {
uint _diff = _balance.sub(_safeWithdraw);
return _balance.sub(_diff.mul(healthFactor)); // technically 150%, not 200%, but adding buffer
}
}
function safeWithdraw() external {
withdraw(maxWithdrawal(msg.sender));
}
// 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);
_rebalance(r);
token.safeTransfer(msg.sender, r);
}
function getPricePerFullShare() external view returns (uint) {
return balance().mul(1e18).div(totalSupply());
}
}
| 231,117 | 11,993 |
db654b914838b056055d114c08ea45ae7102c48af7bdf99877755ab7ebb0a786
| 24,471 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b7/b713c84c4599835c98b6bfc731cc4096e593dd48_FinsClub.sol
| 2,790 | 11,166 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// Sources flattened with hardhat v2.9.4 https://hardhat.org
// File @openzeppelin/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File @openzeppelin/contracts/token/ERC721/IERC721.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// File @openzeppelin/contracts/utils/structs/EnumerableSet.sol
// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
// File @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/IOwnable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
interface IOwnable {
function owner() external view returns (address);
function pushOwnership(address newOwner) external;
function pullOwnership() external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
// File @openzeppelin/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is IOwnable, Context {
address private _owner;
address private _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function pushOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner);
_newOwner = newOwner;
}
function pullOwnership() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
function renounceOwnership() public virtual override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File contracts/FinsClub/FinsClub.sol
contract FinsClub is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private _required;
function length() public view returns (uint256) {
return _required.length();
}
function at(uint256 index) public view returns (address) {
return _required.at(index);
}
function setRequired(address collection) public onlyOwner {
_required.add(collection);
}
function delRequired(address collection) public onlyOwner {
_required.remove(collection);
}
function name() public pure returns (string memory) {
return "Fin's Moon Club";
}
function symbol() public pure returns (string memory) {
return "FMC";
}
function totalSupply() public pure returns (uint256) {
return type(uint256).max;
}
function balanceOf(address account) public view returns (uint256) {
uint256 balance = 0;
for (uint256 i = 0; i < _required.length(); i++) {
address collection = _required.at(i);
balance += IERC721(collection).balanceOf(account);
}
return balance;
}
}
| 315,624 | 11,994 |
9c2f3a8fa0d201cb66384ccc0de0aefe9d931e50566f58e7d54e5203c08d6e9a
| 20,846 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/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;
}
}
| 196,515 | 11,995 |
bd483763d8927a8c54c69571587b1573c28e4bafbb0b6d9ce27864523ecbb7c5
| 30,213 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0a/0a742DAde6b91e26CAB9ff7A4c4a8a72ce679e02_wDB.sol
| 3,204 | 12,548 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ISDB {
function index() external view returns (uint);
}
contract wDB is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sDB;
constructor(address _sDB) ERC20('Wrapped sDB', 'wDB') {
require(_sDB != address(0));
sDB = _sDB;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sDB).transferFrom(msg.sender, address(this), _amount);
uint value = sDBTowDB(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wDBTosDB(_amount);
IERC20(sDB).transfer(msg.sender, value);
return value;
}
function wDBTosDB(uint _amount) public view returns (uint) {
return _amount.mul(ISDB(sDB).index()).div(10 ** decimals());
}
function sDBTowDB(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(ISDB(sDB).index());
}
}
| 88,516 | 11,996 |
bfa6463b008ffa20352b5ca9621c823ebd3c4e4b44f1406538c35eb1d5b3be35
| 29,449 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/90/90e672bd6218a313651831481cde1d6093df7a7a_SHARE.sol
| 5,183 | 18,693 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SHARE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 33333 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = '69SHARE Token';
string private constant _symbol = '69SHARES';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 33333 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 != 0x504535eC709B46aE37Ccac84B90448DD473Bd773, '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;
}
}
| 325,836 | 11,997 |
654212a7364f59c202fb513ecabaf8e55b54c2334bb17be83c8f21ebc5ce003f
| 24,888 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x0d19d264207a3afad4094f26b693ff5590361b0d.sol
| 3,919 | 15,477 |
pragma solidity 0.4.24;
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
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;
}
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 balance) {
return balances[_owner];
}
}
contract RotoToken is StandardToken {
string public constant name = "Roto"; // token name
string public constant symbol = "ROTO"; // token symbol
uint8 public constant decimals = 18; // token decimal
uint256 public constant INITIAL_SUPPLY = 21000000 * (10 ** uint256(decimals));
address owner;
address roto = this;
address manager;
// keeps track of the ROTO currently staked in a tournament
// the format is user address -> the tournament they staked in -> how much they staked
mapping (address => mapping (bytes32 => uint256)) stakes;
uint256 owner_transfer = 2000000 * (10** uint256(decimals));
modifier onlyOwner {
require(msg.sender==owner);
_;
}
modifier onlyManager {
require(msg.sender==manager);
_;
}
event ManagerChanged(address _contract);
event RotoStaked(address _user, uint256 stake);
event RotoReleased(address _user, uint256 stake);
event RotoDestroyed(address _user, uint256 stake);
event RotoRewarded(address _contract, address _user, uint256 reward);
constructor() public {
owner = msg.sender;
totalSupply_ = INITIAL_SUPPLY;
balances[roto] = INITIAL_SUPPLY;
emit Transfer(0x0, roto, INITIAL_SUPPLY);
}
function transferFromContract(address _to, uint256 _value) public onlyOwner returns(bool) {
require(_to!=address(0));
require(_value<=balances[roto]);
require(owner_transfer > 0);
owner_transfer = owner_transfer.sub(_value);
balances[roto] = balances[roto].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(roto, _to, _value);
return true;
}
function setManagerContract(address _contract) external onlyOwner returns(bool) {
//checks that the address sent isn't the 0 address, the owner or the token contract
require(_contract!=address(0)&&_contract!=roto);
// requires that the address sent be a contract
uint size;
assembly { size := extcodesize(_contract) }
require(size > 0);
manager = _contract;
emit ManagerChanged(_contract);
return true;
}
function releaseRoto(address _user, bytes32 _tournamentID) external onlyManager returns(bool) {
require(_user!=address(0));
uint256 value = stakes[_user][_tournamentID];
require(value > 0);
stakes[_user][_tournamentID] = 0;
balances[_user] = balances[_user].add(value);
emit RotoReleased(_user, value);
return true;
}
function destroyRoto(address _user, bytes32 _tournamentID) external onlyManager returns(bool) {
require(_user!=address(0));
uint256 value = stakes[_user][_tournamentID];
require(value > 0);
stakes[_user][_tournamentID] = 0;
balances[roto] = balances[roto].add(value);
emit RotoDestroyed(_user, value);
return true;
}
function stakeRoto(address _user, bytes32 _tournamentID, uint256 _value) external onlyManager returns(bool) {
require(_user!=address(0));
require(_value<=balances[_user]);
require(stakes[_user][_tournamentID] == 0);
balances[_user] = balances[_user].sub(_value);
stakes[_user][_tournamentID] = _value;
emit RotoStaked(_user, _value);
return true;
}
function rewardRoto(address _user, uint256 _value) external onlyManager returns(bool successful) {
require(_user!=address(0));
require(_value<=balances[roto]);
balances[_user] = balances[_user].add(_value);
balances[roto] = balances[roto].sub(_value);
emit Transfer(roto, _user, _value);
return true;
}
function canStake(address _user, uint256 _value) public view onlyManager returns(bool) {
require(_user!=address(0));
require(_value<=balances[_user]);
return true;
}
function getManager() public view returns (address _manager) {
return manager;
}
function changeOwner(address _newOwner) public onlyOwner returns(bool) {
owner = _newOwner;
}
}
contract RotoBasic {
mapping (bytes32 => Tournament) public tournaments; // tournamentID
//Instance and Address of the RotoToken contract
RotoToken token;
address roto;
//Address of the contract owner the manager contract(this contract)
address owner;
address manager;
//boolean variable that determines whether there's an emergency state
bool emergency;
struct Tournament {
bool open;
// the total ether prize and how much is left
uint256 etherPrize;
uint256 etherLeft;
// the total roto prize how much is left
uint256 rotoPrize;
uint256 rotoLeft;
// tournament details
uint256 creationTime;
mapping (address => mapping (bytes32 => Stake)) stakes; // address of staker, to tournament ID points to a specific stake
//counters to easily tell the # of stakes vs # of stakes resolved
uint256 userStakes;
uint256 stakesResolved;
}
struct Stake {
uint256 amount; // Once the stake is resolved, this becomes 0
bool successful;
bool resolved;
}
modifier onlyOwner {
require(msg.sender==owner);
_;
}
modifier stopInEmergency {
require(emergency==false);
_;
}
//Tournament Creation and Processing Events
event StakeProcessed(address indexed staker, uint256 totalAmountStaked, bytes32 indexed tournamentID);
event StakeDestroyed(bytes32 indexed tournamentID, address indexed stakerAddress, uint256 rotoLost);
event StakeReleased(bytes32 indexed tournamentID, address indexed stakerAddress, uint256 etherReward, uint256 rotoStaked);
event SubmissionRewarded(bytes32 indexed tournamentID, address indexed stakerAddress, uint256 rotoReward);
event TokenChanged(address _contract);
event TournamentCreated(bytes32 indexed tournamentID, uint256 etherPrize, uint256 rotoPrize);
event TournamentClosed(bytes32 indexed tournamentID);
function setTokenContract(address _contract) public onlyOwner returns(bool) {
require(_contract!=address(0)&&_contract!=manager);
// requires that the address sent be a contract
uint size;
assembly { size := extcodesize(_contract) }
require(size > 0);
roto = _contract;
token = RotoToken(roto);
emit TokenChanged(_contract);
return true;
}
function setEmergency(bool _emergency) public onlyOwner returns(bool) {
emergency = _emergency;
return true;
}
function changeOwner(address _newOwner) public onlyOwner returns(bool) {
owner = _newOwner;
}
}
contract RotoManager is RotoBasic {
using SafeMath for uint256;
constructor() public {
owner = msg.sender;
emergency = false;
manager = this;
}
function releaseRoto(address _user, bytes32 _tournamentID, uint256 _etherReward) external onlyOwner stopInEmergency returns(bool successful){
Tournament storage tournament = tournaments[_tournamentID];
require(tournament.open==true);
Stake storage user_stake = tournament.stakes[_user][_tournamentID];
uint256 initial_stake = user_stake.amount;
// prelimiary checks
require(initial_stake > 0);
require(user_stake.resolved == false);
// ether balance rewards
require(manager.balance > _etherReward);
require(tournament.etherLeft >= _etherReward);
//Redistributes roto back to the user, and marks the stake as successful and completed
user_stake.amount = 0;
assert(token.releaseRoto(_user, _tournamentID)); // calls the token contract releaseRoto function to handle the token accounting
tournament.stakesResolved = tournament.stakesResolved.add(1);
user_stake.resolved = true;
user_stake.successful = true;
if(_etherReward > 0) {
tournament.etherLeft = tournament.etherLeft.sub(_etherReward);
_user.transfer(_etherReward);
}
emit StakeReleased(_tournamentID, _user, _etherReward, initial_stake);
return true;
}
function rewardRoto(address _user, bytes32 _tournamentID, uint256 _rotoReward) external onlyOwner stopInEmergency returns(bool successful) {
Tournament storage tournament = tournaments[_tournamentID];
require(tournament.open==true);
Stake storage user_stake = tournament.stakes[_user][_tournamentID];
uint256 initial_stake = user_stake.amount;
require(initial_stake==0);
require(tournament.rotoLeft >= _rotoReward);
require(user_stake.resolved == false);
tournament.rotoLeft = tournament.rotoLeft.sub(_rotoReward);
assert(token.rewardRoto(_user, _rotoReward));
user_stake.resolved = true;
user_stake.successful = true;
emit SubmissionRewarded(_tournamentID, _user, _rotoReward);
return true;
}
function destroyRoto(address _user, bytes32 _tournamentID) external onlyOwner stopInEmergency returns(bool successful) {
Tournament storage tournament = tournaments[_tournamentID];
require(tournament.open==true);
Stake storage user_stake = tournament.stakes[_user][_tournamentID];
uint256 initial_stake = user_stake.amount;
require(initial_stake > 0);
require(user_stake.resolved == false);
user_stake.amount = 0;
user_stake.resolved = true;
user_stake.successful = false;
assert(token.destroyRoto(_user, _tournamentID));
tournament.stakesResolved = tournament.stakesResolved.add(1);
emit StakeDestroyed(_tournamentID, _user, initial_stake);
return true;
}
function stake(uint256 _value, bytes32 _tournamentID) external stopInEmergency returns(bool successful) {
return _stake(msg.sender, _tournamentID, _value);
}
function _stake(address _staker, bytes32 _tournamentID, uint256 _value) internal returns(bool successful) {
Tournament storage tournament = tournaments[_tournamentID];
//The User can't submit after tournament closure and the tournament must have begun
require((tournament.open==true));
require(tournament.etherPrize>0);
Stake storage user_stake = tournament.stakes[_staker][_tournamentID];
require(user_stake.amount==0); // Users can only stake once
require(_value>0); // Users must stake at least 1 ROTO
require(_staker != roto && _staker != owner); //RotoHive can't stake in tournament
//Users must have the necessary balances to submit their stake
assert(token.canStake(_staker, _value));
user_stake.amount = _value;
assert(token.stakeRoto(_staker,_tournamentID,_value));
// adds the stake the submission
tournament.userStakes = tournament.userStakes.add(1);
emit StakeProcessed(_staker, user_stake.amount, _tournamentID);
return true;
}
function createTournament(bytes32 _tournamentID, uint256 _etherPrize, uint256 _rotoPrize) external payable onlyOwner returns(bool successful) {
Tournament storage newTournament = tournaments[_tournamentID];
require(newTournament.creationTime==0);
newTournament.open = true;
newTournament.etherPrize = _etherPrize;
newTournament.etherLeft = _etherPrize;
newTournament.rotoPrize = _rotoPrize;
newTournament.rotoLeft = _rotoPrize;
newTournament.creationTime = block.timestamp;
emit TournamentCreated(_tournamentID, _etherPrize, _rotoPrize);
return true;
}
function closeTournament(bytes32 _tournamentID) external onlyOwner returns(bool successful) {
Tournament storage tournament = tournaments[_tournamentID];
// the tournament should be open
require(tournament.open==true);
// all the prizes should have been given out
require(tournament.rotoLeft == 0 && tournament.etherLeft == 0);
// all the users stakes should have been resolved
require(tournament.userStakes == tournament.stakesResolved);
tournament.open = false;
emit TournamentClosed(_tournamentID);
return true;
}
}
| 141,271 | 11,998 |
a34ac4c3b4e2bbb6bc5558acc7d3b45c97c3a95d1aa4389d5ec6ba1764815f26
| 21,219 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTf1AJjAL3bh2AC8meP61vJF7LkGMQUU9b_TronFire.sol
| 5,281 | 20,229 |
//SourceUnit: tronfire.sol
pragma solidity 0.5.10;
contract XGOLD {
function deposit(address sender, address referrer) public payable;
}
contract TronFire {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 15;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
XGOLD public xGOLD;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public
{
levelPrice[1] = 10 trx;
levelPrice[2] = 20 trx;
levelPrice[3] = 40 trx;
levelPrice[4] = 80 trx;
levelPrice[5] = 1600 trx;
levelPrice[6] = 3200 trx;
levelPrice[7] = 6400 trx;
levelPrice[8] = 12800 trx;
levelPrice[9] = 25600 trx;
levelPrice[10] = 51200 trx;
levelPrice[11] = 102400 trx;
levelPrice[12] = 204800 trx;
levelPrice[13] = 358400 trx;
levelPrice[14] = 819200 trx;
levelPrice[15] = 1638400 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable
{
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function setXGold(address xGoldAddress) public
{
require(msg.sender == owner, "onlyOwner");
require(address(xGOLD) == address(0));
xGOLD = XGOLD(xGoldAddress);
}
function withdrawLostTRXFromBalance() public
{
require(msg.sender == owner, "onlyOwner");
msg.sender.transfer(address(this).balance);
}
function registrationExt(address referrerAddress) external payable
{
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
if (address(xGOLD) != address(0)) {
xGOLD.deposit(userAddress, referrerAddress);
require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost");
} else {
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
}
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
if(level>1)
return sendETHDividends(referrerAddress, userAddress, 2, level);
else
return sendETHDividends(owner, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint256) {
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, address, uint256) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
//41a4e7176790732f8a2a7593902d63748386923531
| 287,112 | 11,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.